@dxos/client
    Preparing search index...

    Class Rpcs

    Effect RPC definitions for dxos.client.services.SpacesService. Service-only payloads use Effect schemas; shared proto types remain protobuf-encoded on the wire.

    Hierarchy

    • Rpcs_base
      • Rpcs
    Index

    Constructors

    constructor

    Properties

    ~effect/rpc/RpcGroup annotations requests

    Methods

    accessHandler add annotate annotateMerge annotateRpcs annotateRpcsMerge merge middleware of omit pipe prefix toHandlers toLayer toLayerHandler

    Constructors

    • Parameters

      • _: never

      Returns Rpcs

    Properties

    "~effect/rpc/RpcGroup": "~effect/rpc/RpcGroup"
    annotations: Context<never>
    requests: ReadonlyMap<
        string,
        | Rpc<
            "SpacesService.admitContact",
            Struct<
                {
                    contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                    role: Enum<
                        {
                            ADMIN: number;
                            EDITOR: number;
                            INVALID: number;
                            OWNER: number;
                            READER: number;
                            REMOVED: number;
                        },
                    >;
                    spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                },
            >,
            Void,
            Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
            never,
            never,
        >
        | Rpc<
            "SpacesService.createEpoch",
            Struct<
                {
                    automergeRootUrl: optional<String>;
                    migration: optional<
                        Enum<
                            {
                                FRAGMENT_AUTOMERGE_ROOT: number;
                                INIT_AUTOMERGE: number;
                                MIGRATE_REFERENCES_TO_DXN: number;
                                NONE: number;
                                PRUNE_AUTOMERGE_ROOT_HISTORY: number;
                                REPLACE_AUTOMERGE_ROOT: number;
                            },
                        >,
                    >;
                    spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                },
            >,
            Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
            Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
            never,
            never,
        >
        | Rpc<
            "SpacesService.createSpace",
            Struct<
                {
                    membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                    tags: optional<mutable<$Array<String>>>;
                },
            >,
            Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
            Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
            never,
            never,
        >
        | Rpc<
            "SpacesService.exportSpace",
            Struct<
                {
                    format: optional<Enum<{ BINARY: number; JSON: number }>>;
                    spaceId: String;
                },
            >,
            Struct<
                {
                    archive: Struct<
                        {
                            contents: Uint8Array;
                            filename: String;
                            format: optional<Enum<{ BINARY: number; JSON: number }>>;
                        },
                    >;
                },
            >,
            Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
            never,
            never,
        >
        | Rpc<
            "SpacesService.importSpace",
            Struct<
                {
                    archive: Struct<
                        {
                            contents: Uint8Array;
                            filename: String;
                            format: optional<Enum<{ BINARY: number; JSON: number }>>;
                        },
                    >;
                    tags: optional<mutable<$Array<String>>>;
                },
            >,
            Struct<{ newSpaceId: String }>,
            Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
            never,
            never,
        >
        | Rpc<
            "SpacesService.joinBySpaceKey",
            Struct<
                {
                    spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                },
            >,
            Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
            Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
            never,
            never,
        >
        | Rpc<
            "SpacesService.postMessage",
            Struct<
                {
                    channel: String;
                    message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                    spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                },
            >,
            Void,
            Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
            never,
            never,
        >
        | Rpc<
            "SpacesService.queryCredentials",
            Struct<
                {
                    noTail: optional<Boolean>;
                    spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                },
            >,
            Stream<
                Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
            >,
            Never,
            never,
            never,
        >
        | Rpc<
            "SpacesService.querySpaces",
            Void,
            Stream<
                Codec<QuerySpacesResponse, Uint8Array<ArrayBufferLike>, never, never>,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
            >,
            Never,
            never,
            never,
        >
        | Rpc<
            "SpacesService.subscribeMessages",
            Struct<
                {
                    channel: String;
                    spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                },
            >,
            Stream<
                Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
            >,
            Never,
            never,
            never,
        >
        | Rpc<
            "SpacesService.updateMemberRole",
            Struct<
                {
                    memberKey: Codec<
                        PublicKey,
                        Uint8Array<ArrayBufferLike>,
                        never,
                        never,
                    >;
                    newRole: Enum<
                        {
                            ADMIN: number;
                            EDITOR: number;
                            INVALID: number;
                            OWNER: number;
                            READER: number;
                            REMOVED: number;
                        },
                    >;
                    spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                },
            >,
            Void,
            Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
            never,
            never,
        >
        | Rpc<
            "SpacesService.updateSpace",
            Struct<
                {
                    edgeReplication: optional<
                        Enum<{ DISABLED: number; ENABLED: number }>,
                    >;
                    spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    state: optional<
                        Enum<
                            {
                                INVALID: number;
                                SPACE_ACTIVE: number;
                                SPACE_CLOSED: number;
                                SPACE_CONTROL_ONLY: number;
                                SPACE_DELETED: number;
                                SPACE_ERROR: number;
                                SPACE_INACTIVE: number;
                                SPACE_INITIALIZING: number;
                                SPACE_READY: number;
                                SPACE_REQUIRES_MIGRATION: number;
                            },
                        >,
                    >;
                },
            >,
            Void,
            Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
            never,
            never,
        >
        | Rpc<
            "SpacesService.writeCredentials",
            Struct<
                {
                    credentials: optional<
                        mutable<
                            $Array<
                                Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                            >,
                        >,
                    >;
                    spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                },
            >,
            Void,
            Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
            never,
            never,
        >,
    >

    Methods

    • Retrieve a handler for a specific procedure in the group.

      Type Parameters

      • const Tag extends
            | "SpacesService.admitContact"
            | "SpacesService.createEpoch"
            | "SpacesService.createSpace"
            | "SpacesService.exportSpace"
            | "SpacesService.importSpace"
            | "SpacesService.joinBySpaceKey"
            | "SpacesService.postMessage"
            | "SpacesService.queryCredentials"
            | "SpacesService.querySpaces"
            | "SpacesService.subscribeMessages"
            | "SpacesService.updateMemberRole"
            | "SpacesService.updateSpace"
            | "SpacesService.writeCredentials"

      Parameters

      Returns Effect<
          (
              payload:
                  | Payload<
                      Extract<
                          Rpc<
                              "SpacesService.admitContact",
                              Struct<
                                  {
                                      contact: Codec<
                                          Contact,
                                          Uint8Array<ArrayBufferLike>,
                                          never,
                                          never,
                                      >;
                                      role: Enum<
                                          {
                                              ADMIN: number;
                                              EDITOR: number;
                                              INVALID: number;
                                              OWNER: number;
                                              READER: number;
                                              REMOVED: number;
                                          },
                                      >;
                                      spaceKey: Codec<
                                          PublicKey,
                                          Uint8Array<ArrayBufferLike>,
                                          never,
                                          never,
                                      >;
                                  },
                              >,
                              Void,
                              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                              never,
                              never,
                          >,
                          { _tag: Tag },
                      >,
                  >
                  | Payload<
                      Extract<
                          Rpc<
                              "SpacesService.createEpoch",
                              Struct<
                                  {
                                      automergeRootUrl: optional<String>;
                                      migration: optional<
                                          Enum<
                                              {
                                                  FRAGMENT_AUTOMERGE_ROOT: ...;
                                                  INIT_AUTOMERGE: ...;
                                                  MIGRATE_REFERENCES_TO_DXN: ...;
                                                  NONE: ...;
                                                  PRUNE_AUTOMERGE_ROOT_HISTORY: ...;
                                                  REPLACE_AUTOMERGE_ROOT: ...;
                                              },
                                          >,
                                      >;
                                      spaceKey: Codec<
                                          PublicKey,
                                          Uint8Array<ArrayBufferLike>,
                                          never,
                                          never,
                                      >;
                                  },
                              >,
                              Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
                              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                              never,
                              never,
                          >,
                          { _tag: Tag },
                      >,
                  >
                  | Payload<
                      Extract<
                          Rpc<
                              "SpacesService.createSpace",
                              Struct<
                                  {
                                      membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                                      tags: optional<mutable<$Array<(...)>>>;
                                  },
                              >,
                              Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
                              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                              never,
                              never,
                          >,
                          { _tag: Tag },
                      >,
                  >
                  | Payload<
                      Extract<
                          Rpc<
                              "SpacesService.exportSpace",
                              Struct<
                                  {
                                      format: optional<Enum<{ BINARY: ...; JSON: ... }>>;
                                      spaceId: String;
                                  },
                              >,
                              Struct<
                                  {
                                      archive: Struct<
                                          {
                                              contents: Uint8Array;
                                              filename: String;
                                              format: optional<(...)>;
                                          },
                                      >;
                                  },
                              >,
                              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                              never,
                              never,
                          >,
                          { _tag: Tag },
                      >,
                  >
                  | Payload<
                      Extract<
                          Rpc<
                              "SpacesService.importSpace",
                              Struct<
                                  {
                                      archive: Struct<
                                          {
                                              contents: Uint8Array;
                                              filename: String;
                                              format: optional<(...)>;
                                          },
                                      >;
                                      tags: optional<mutable<$Array<(...)>>>;
                                  },
                              >,
                              Struct<{ newSpaceId: String }>,
                              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                              never,
                              never,
                          >,
                          { _tag: Tag },
                      >,
                  >
                  | Payload<
                      Extract<
                          Rpc<
                              "SpacesService.joinBySpaceKey",
                              Struct<
                                  {
                                      spaceKey: Codec<
                                          PublicKey,
                                          Uint8Array<ArrayBufferLike>,
                                          never,
                                          never,
                                      >;
                                  },
                              >,
                              Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
                              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                              never,
                              never,
                          >,
                          { _tag: Tag },
                      >,
                  >
                  | Payload<
                      Extract<
                          Rpc<
                              "SpacesService.postMessage",
                              Struct<
                                  {
                                      channel: String;
                                      message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                                      spaceKey: Codec<
                                          PublicKey,
                                          Uint8Array<ArrayBufferLike>,
                                          never,
                                          never,
                                      >;
                                  },
                              >,
                              Void,
                              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                              never,
                              never,
                          >,
                          { _tag: Tag },
                      >,
                  >
                  | Payload<
                      Extract<
                          Rpc<
                              "SpacesService.queryCredentials",
                              Struct<
                                  {
                                      noTail: optional<Boolean>;
                                      spaceKey: Codec<
                                          PublicKey,
                                          Uint8Array<ArrayBufferLike>,
                                          never,
                                          never,
                                      >;
                                  },
                              >,
                              Stream<
                                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                              >,
                              Never,
                              never,
                              never,
                          >,
                          { _tag: Tag },
                      >,
                  >
                  | Payload<
                      Extract<
                          Rpc<
                              "SpacesService.querySpaces",
                              Void,
                              Stream<
                                  Codec<
                                      QuerySpacesResponse,
                                      Uint8Array<ArrayBufferLike>,
                                      never,
                                      never,
                                  >,
                                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                              >,
                              Never,
                              never,
                              never,
                          >,
                          { _tag: Tag },
                      >,
                  >
                  | Payload<
                      Extract<
                          Rpc<
                              "SpacesService.subscribeMessages",
                              Struct<
                                  {
                                      channel: String;
                                      spaceKey: Codec<
                                          PublicKey,
                                          Uint8Array<ArrayBufferLike>,
                                          never,
                                          never,
                                      >;
                                  },
                              >,
                              Stream<
                                  Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                              >,
                              Never,
                              never,
                              never,
                          >,
                          { _tag: Tag },
                      >,
                  >
                  | Payload<
                      Extract<
                          Rpc<
                              "SpacesService.updateMemberRole",
                              Struct<
                                  {
                                      memberKey: Codec<
                                          PublicKey,
                                          Uint8Array<ArrayBufferLike>,
                                          never,
                                          never,
                                      >;
                                      newRole: Enum<
                                          {
                                              ADMIN: number;
                                              EDITOR: number;
                                              INVALID: number;
                                              OWNER: number;
                                              READER: number;
                                              REMOVED: number;
                                          },
                                      >;
                                      spaceKey: Codec<
                                          PublicKey,
                                          Uint8Array<ArrayBufferLike>,
                                          never,
                                          never,
                                      >;
                                  },
                              >,
                              Void,
                              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                              never,
                              never,
                          >,
                          { _tag: Tag },
                      >,
                  >
                  | Payload<
                      Extract<
                          Rpc<
                              "SpacesService.updateSpace",
                              Struct<
                                  {
                                      edgeReplication: optional<Enum<{ DISABLED: ...; ENABLED: ... }>>;
                                      spaceKey: Codec<
                                          PublicKey,
                                          Uint8Array<ArrayBufferLike>,
                                          never,
                                          never,
                                      >;
                                      state: optional<
                                          Enum<
                                              {
                                                  INVALID: ...;
                                                  SPACE_ACTIVE: ...;
                                                  SPACE_CLOSED: ...;
                                                  SPACE_CONTROL_ONLY: ...;
                                                  SPACE_DELETED: ...;
                                                  SPACE_ERROR: ...;
                                                  SPACE_INACTIVE: ...;
                                                  SPACE_INITIALIZING: ...;
                                                  SPACE_READY: ...;
                                                  SPACE_REQUIRES_MIGRATION: ...;
                                              },
                                          >,
                                      >;
                                  },
                              >,
                              Void,
                              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                              never,
                              never,
                          >,
                          { _tag: Tag },
                      >,
                  >
                  | Payload<
                      Extract<
                          Rpc<
                              "SpacesService.writeCredentials",
                              Struct<
                                  {
                                      credentials: optional<mutable<$Array<(...)>>>;
                                      spaceKey: Codec<
                                          PublicKey,
                                          Uint8Array<ArrayBufferLike>,
                                          never,
                                          never,
                                      >;
                                  },
                              >,
                              Void,
                              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                              never,
                              never,
                          >,
                          { _tag: Tag },
                      >,
                  >,
              options: { client: ServerClient; headers: Headers; requestId: RequestId },
          ) =>
              | ResultFrom<
                  Extract<
                      Rpc<
                          "SpacesService.admitContact",
                          Struct<
                              {
                                  contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                                  role: Enum<
                                      {
                                          ADMIN: number;
                                          EDITOR: number;
                                          INVALID: number;
                                          OWNER: number;
                                          READER: number;
                                          REMOVED: number;
                                      },
                                  >;
                                  spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                              },
                          >,
                          Void,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                          never,
                          never,
                      >,
                      { _tag: Tag },
                  >,
                  never,
              >
              | ResultFrom<
                  Extract<
                      Rpc<
                          "SpacesService.createEpoch",
                          Struct<
                              {
                                  automergeRootUrl: optional<String>;
                                  migration: optional<
                                      Enum<
                                          {
                                              FRAGMENT_AUTOMERGE_ROOT: ...;
                                              INIT_AUTOMERGE: ...;
                                              MIGRATE_REFERENCES_TO_DXN: ...;
                                              NONE: ...;
                                              PRUNE_AUTOMERGE_ROOT_HISTORY: ...;
                                              REPLACE_AUTOMERGE_ROOT: ...;
                                          },
                                      >,
                                  >;
                                  spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                              },
                          >,
                          Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                          never,
                          never,
                      >,
                      { _tag: Tag },
                  >,
                  never,
              >
              | ResultFrom<
                  Extract<
                      Rpc<
                          "SpacesService.createSpace",
                          Struct<
                              {
                                  membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                                  tags: optional<mutable<$Array<(...)>>>;
                              },
                          >,
                          Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                          never,
                          never,
                      >,
                      { _tag: Tag },
                  >,
                  never,
              >
              | ResultFrom<
                  Extract<
                      Rpc<
                          "SpacesService.exportSpace",
                          Struct<
                              {
                                  format: optional<Enum<{ BINARY: ...; JSON: ... }>>;
                                  spaceId: String;
                              },
                          >,
                          Struct<
                              {
                                  archive: Struct<
                                      {
                                          contents: Uint8Array;
                                          filename: String;
                                          format: optional<(...)>;
                                      },
                                  >;
                              },
                          >,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                          never,
                          never,
                      >,
                      { _tag: Tag },
                  >,
                  never,
              >
              | ResultFrom<
                  Extract<
                      Rpc<
                          "SpacesService.importSpace",
                          Struct<
                              {
                                  archive: Struct<
                                      {
                                          contents: Uint8Array;
                                          filename: String;
                                          format: optional<(...)>;
                                      },
                                  >;
                                  tags: optional<mutable<$Array<(...)>>>;
                              },
                          >,
                          Struct<{ newSpaceId: String }>,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                          never,
                          never,
                      >,
                      { _tag: Tag },
                  >,
                  never,
              >
              | ResultFrom<
                  Extract<
                      Rpc<
                          "SpacesService.joinBySpaceKey",
                          Struct<
                              {
                                  spaceKey: Codec<
                                      PublicKey,
                                      Uint8Array<ArrayBufferLike>,
                                      never,
                                      never,
                                  >;
                              },
                          >,
                          Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                          never,
                          never,
                      >,
                      { _tag: Tag },
                  >,
                  never,
              >
              | ResultFrom<
                  Extract<
                      Rpc<
                          "SpacesService.postMessage",
                          Struct<
                              {
                                  channel: String;
                                  message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                                  spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                              },
                          >,
                          Void,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                          never,
                          never,
                      >,
                      { _tag: Tag },
                  >,
                  never,
              >
              | ResultFrom<
                  Extract<
                      Rpc<
                          "SpacesService.queryCredentials",
                          Struct<
                              {
                                  noTail: optional<Boolean>;
                                  spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                              },
                          >,
                          Stream<
                              Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                          >,
                          Never,
                          never,
                          never,
                      >,
                      { _tag: Tag },
                  >,
                  never,
              >
              | ResultFrom<
                  Extract<
                      Rpc<
                          "SpacesService.querySpaces",
                          Void,
                          Stream<
                              Codec<
                                  QuerySpacesResponse,
                                  Uint8Array<ArrayBufferLike>,
                                  never,
                                  never,
                              >,
                              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                          >,
                          Never,
                          never,
                          never,
                      >,
                      { _tag: Tag },
                  >,
                  never,
              >
              | ResultFrom<
                  Extract<
                      Rpc<
                          "SpacesService.subscribeMessages",
                          Struct<
                              {
                                  channel: String;
                                  spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                              },
                          >,
                          Stream<
                              Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                          >,
                          Never,
                          never,
                          never,
                      >,
                      { _tag: Tag },
                  >,
                  never,
              >
              | ResultFrom<
                  Extract<
                      Rpc<
                          "SpacesService.updateMemberRole",
                          Struct<
                              {
                                  memberKey: Codec<
                                      PublicKey,
                                      Uint8Array<ArrayBufferLike>,
                                      never,
                                      never,
                                  >;
                                  newRole: Enum<
                                      {
                                          ADMIN: number;
                                          EDITOR: number;
                                          INVALID: number;
                                          OWNER: number;
                                          READER: number;
                                          REMOVED: number;
                                      },
                                  >;
                                  spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                              },
                          >,
                          Void,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                          never,
                          never,
                      >,
                      { _tag: Tag },
                  >,
                  never,
              >
              | ResultFrom<
                  Extract<
                      Rpc<
                          "SpacesService.updateSpace",
                          Struct<
                              {
                                  edgeReplication: optional<Enum<{ DISABLED: ...; ENABLED: ... }>>;
                                  spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                                  state: optional<
                                      Enum<
                                          {
                                              INVALID: ...;
                                              SPACE_ACTIVE: ...;
                                              SPACE_CLOSED: ...;
                                              SPACE_CONTROL_ONLY: ...;
                                              SPACE_DELETED: ...;
                                              SPACE_ERROR: ...;
                                              SPACE_INACTIVE: ...;
                                              SPACE_INITIALIZING: ...;
                                              SPACE_READY: ...;
                                              SPACE_REQUIRES_MIGRATION: ...;
                                          },
                                      >,
                                  >;
                              },
                          >,
                          Void,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                          never,
                          never,
                      >,
                      { _tag: Tag },
                  >,
                  never,
              >
              | ResultFrom<
                  Extract<
                      Rpc<
                          "SpacesService.writeCredentials",
                          Struct<
                              {
                                  credentials: optional<mutable<$Array<(...)>>>;
                                  spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                              },
                          >,
                          Void,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                          never,
                          never,
                      >,
                      { _tag: Tag },
                  >,
                  never,
              >,
          never,
          Handler<Tag>,
      >

    • Add one or more procedures to the group.

      Type Parameters

      • const Rpcs2 extends readonly Any[]

      Parameters

      Returns RpcGroup<
          | Rpc<
              "SpacesService.admitContact",
              Struct<
                  {
                      contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                      role: Enum<
                          {
                              ADMIN: number;
                              EDITOR: number;
                              INVALID: number;
                              OWNER: number;
                              READER: number;
                              REMOVED: number;
                          },
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.createEpoch",
              Struct<
                  {
                      automergeRootUrl: optional<String>;
                      migration: optional<
                          Enum<
                              {
                                  FRAGMENT_AUTOMERGE_ROOT: number;
                                  INIT_AUTOMERGE: number;
                                  MIGRATE_REFERENCES_TO_DXN: number;
                                  NONE: number;
                                  PRUNE_AUTOMERGE_ROOT_HISTORY: number;
                                  REPLACE_AUTOMERGE_ROOT: number;
                              },
                          >,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.createSpace",
              Struct<
                  {
                      membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                      tags: optional<mutable<$Array<String>>>;
                  },
              >,
              Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.exportSpace",
              Struct<
                  {
                      format: optional<Enum<{ BINARY: number; JSON: number }>>;
                      spaceId: String;
                  },
              >,
              Struct<
                  {
                      archive: Struct<
                          {
                              contents: Uint8Array;
                              filename: String;
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          },
                      >;
                  },
              >,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.importSpace",
              Struct<
                  {
                      archive: Struct<
                          {
                              contents: Uint8Array;
                              filename: String;
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          },
                      >;
                      tags: optional<mutable<$Array<String>>>;
                  },
              >,
              Struct<{ newSpaceId: String }>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.joinBySpaceKey",
              Struct<
                  {
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.postMessage",
              Struct<
                  {
                      channel: String;
                      message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.queryCredentials",
              Struct<
                  {
                      noTail: optional<Boolean>;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Stream<
                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.querySpaces",
              Void,
              Stream<
                  Codec<QuerySpacesResponse, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.subscribeMessages",
              Struct<
                  {
                      channel: String;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Stream<
                  Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.updateMemberRole",
              Struct<
                  {
                      memberKey: Codec<
                          PublicKey,
                          Uint8Array<ArrayBufferLike>,
                          never,
                          never,
                      >;
                      newRole: Enum<
                          {
                              ADMIN: number;
                              EDITOR: number;
                              INVALID: number;
                              OWNER: number;
                              READER: number;
                              REMOVED: number;
                          },
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.updateSpace",
              Struct<
                  {
                      edgeReplication: optional<
                          Enum<{ DISABLED: number; ENABLED: number }>,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                      state: optional<
                          Enum<
                              {
                                  INVALID: number;
                                  SPACE_ACTIVE: number;
                                  SPACE_CLOSED: number;
                                  SPACE_CONTROL_ONLY: number;
                                  SPACE_DELETED: number;
                                  SPACE_ERROR: number;
                                  SPACE_INACTIVE: number;
                                  SPACE_INITIALIZING: number;
                                  SPACE_READY: number;
                                  SPACE_REQUIRES_MIGRATION: number;
                              },
                          >,
                      >;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.writeCredentials",
              Struct<
                  {
                      credentials: optional<
                          mutable<
                              $Array<
                                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                              >,
                          >,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpcs2[number],
      >

    • Annotate the group with a value.

      Type Parameters

      • I
      • S

      Parameters

      • service: Key<I, S>
      • value: S

      Returns RpcGroup<
          | Rpc<
              "SpacesService.admitContact",
              Struct<
                  {
                      contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                      role: Enum<
                          {
                              ADMIN: number;
                              EDITOR: number;
                              INVALID: number;
                              OWNER: number;
                              READER: number;
                              REMOVED: number;
                          },
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.createEpoch",
              Struct<
                  {
                      automergeRootUrl: optional<String>;
                      migration: optional<
                          Enum<
                              {
                                  FRAGMENT_AUTOMERGE_ROOT: number;
                                  INIT_AUTOMERGE: number;
                                  MIGRATE_REFERENCES_TO_DXN: number;
                                  NONE: number;
                                  PRUNE_AUTOMERGE_ROOT_HISTORY: number;
                                  REPLACE_AUTOMERGE_ROOT: number;
                              },
                          >,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.createSpace",
              Struct<
                  {
                      membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                      tags: optional<mutable<$Array<String>>>;
                  },
              >,
              Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.exportSpace",
              Struct<
                  {
                      format: optional<Enum<{ BINARY: number; JSON: number }>>;
                      spaceId: String;
                  },
              >,
              Struct<
                  {
                      archive: Struct<
                          {
                              contents: Uint8Array;
                              filename: String;
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          },
                      >;
                  },
              >,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.importSpace",
              Struct<
                  {
                      archive: Struct<
                          {
                              contents: Uint8Array;
                              filename: String;
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          },
                      >;
                      tags: optional<mutable<$Array<String>>>;
                  },
              >,
              Struct<{ newSpaceId: String }>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.joinBySpaceKey",
              Struct<
                  {
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.postMessage",
              Struct<
                  {
                      channel: String;
                      message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.queryCredentials",
              Struct<
                  {
                      noTail: optional<Boolean>;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Stream<
                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.querySpaces",
              Void,
              Stream<
                  Codec<QuerySpacesResponse, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.subscribeMessages",
              Struct<
                  {
                      channel: String;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Stream<
                  Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.updateMemberRole",
              Struct<
                  {
                      memberKey: Codec<
                          PublicKey,
                          Uint8Array<ArrayBufferLike>,
                          never,
                          never,
                      >;
                      newRole: Enum<
                          {
                              ADMIN: number;
                              EDITOR: number;
                              INVALID: number;
                              OWNER: number;
                              READER: number;
                              REMOVED: number;
                          },
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.updateSpace",
              Struct<
                  {
                      edgeReplication: optional<
                          Enum<{ DISABLED: number; ENABLED: number }>,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                      state: optional<
                          Enum<
                              {
                                  INVALID: number;
                                  SPACE_ACTIVE: number;
                                  SPACE_CLOSED: number;
                                  SPACE_CONTROL_ONLY: number;
                                  SPACE_DELETED: number;
                                  SPACE_ERROR: number;
                                  SPACE_INACTIVE: number;
                                  SPACE_INITIALIZING: number;
                                  SPACE_READY: number;
                                  SPACE_REQUIRES_MIGRATION: number;
                              },
                          >,
                      >;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.writeCredentials",
              Struct<
                  {
                      credentials: optional<
                          mutable<
                              $Array<
                                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                              >,
                          >,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >,
      >

    • Annotate the group with the provided annotations.

      Type Parameters

      • S

      Parameters

      • annotations: Context<S>

      Returns RpcGroup<
          | Rpc<
              "SpacesService.admitContact",
              Struct<
                  {
                      contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                      role: Enum<
                          {
                              ADMIN: number;
                              EDITOR: number;
                              INVALID: number;
                              OWNER: number;
                              READER: number;
                              REMOVED: number;
                          },
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.createEpoch",
              Struct<
                  {
                      automergeRootUrl: optional<String>;
                      migration: optional<
                          Enum<
                              {
                                  FRAGMENT_AUTOMERGE_ROOT: number;
                                  INIT_AUTOMERGE: number;
                                  MIGRATE_REFERENCES_TO_DXN: number;
                                  NONE: number;
                                  PRUNE_AUTOMERGE_ROOT_HISTORY: number;
                                  REPLACE_AUTOMERGE_ROOT: number;
                              },
                          >,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.createSpace",
              Struct<
                  {
                      membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                      tags: optional<mutable<$Array<String>>>;
                  },
              >,
              Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.exportSpace",
              Struct<
                  {
                      format: optional<Enum<{ BINARY: number; JSON: number }>>;
                      spaceId: String;
                  },
              >,
              Struct<
                  {
                      archive: Struct<
                          {
                              contents: Uint8Array;
                              filename: String;
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          },
                      >;
                  },
              >,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.importSpace",
              Struct<
                  {
                      archive: Struct<
                          {
                              contents: Uint8Array;
                              filename: String;
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          },
                      >;
                      tags: optional<mutable<$Array<String>>>;
                  },
              >,
              Struct<{ newSpaceId: String }>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.joinBySpaceKey",
              Struct<
                  {
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.postMessage",
              Struct<
                  {
                      channel: String;
                      message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.queryCredentials",
              Struct<
                  {
                      noTail: optional<Boolean>;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Stream<
                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.querySpaces",
              Void,
              Stream<
                  Codec<QuerySpacesResponse, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.subscribeMessages",
              Struct<
                  {
                      channel: String;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Stream<
                  Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.updateMemberRole",
              Struct<
                  {
                      memberKey: Codec<
                          PublicKey,
                          Uint8Array<ArrayBufferLike>,
                          never,
                          never,
                      >;
                      newRole: Enum<
                          {
                              ADMIN: number;
                              EDITOR: number;
                              INVALID: number;
                              OWNER: number;
                              READER: number;
                              REMOVED: number;
                          },
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.updateSpace",
              Struct<
                  {
                      edgeReplication: optional<
                          Enum<{ DISABLED: number; ENABLED: number }>,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                      state: optional<
                          Enum<
                              {
                                  INVALID: number;
                                  SPACE_ACTIVE: number;
                                  SPACE_CLOSED: number;
                                  SPACE_CONTROL_ONLY: number;
                                  SPACE_DELETED: number;
                                  SPACE_ERROR: number;
                                  SPACE_INACTIVE: number;
                                  SPACE_INITIALIZING: number;
                                  SPACE_READY: number;
                                  SPACE_REQUIRES_MIGRATION: number;
                              },
                          >,
                      >;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.writeCredentials",
              Struct<
                  {
                      credentials: optional<
                          mutable<
                              $Array<
                                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                              >,
                          >,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >,
      >

    • Annotate the Rpc's above this point with a value.

      Type Parameters

      • I
      • S

      Parameters

      • service: Key<I, S>
      • value: S

      Returns RpcGroup<
          | Rpc<
              "SpacesService.admitContact",
              Struct<
                  {
                      contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                      role: Enum<
                          {
                              ADMIN: number;
                              EDITOR: number;
                              INVALID: number;
                              OWNER: number;
                              READER: number;
                              REMOVED: number;
                          },
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.createEpoch",
              Struct<
                  {
                      automergeRootUrl: optional<String>;
                      migration: optional<
                          Enum<
                              {
                                  FRAGMENT_AUTOMERGE_ROOT: number;
                                  INIT_AUTOMERGE: number;
                                  MIGRATE_REFERENCES_TO_DXN: number;
                                  NONE: number;
                                  PRUNE_AUTOMERGE_ROOT_HISTORY: number;
                                  REPLACE_AUTOMERGE_ROOT: number;
                              },
                          >,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.createSpace",
              Struct<
                  {
                      membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                      tags: optional<mutable<$Array<String>>>;
                  },
              >,
              Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.exportSpace",
              Struct<
                  {
                      format: optional<Enum<{ BINARY: number; JSON: number }>>;
                      spaceId: String;
                  },
              >,
              Struct<
                  {
                      archive: Struct<
                          {
                              contents: Uint8Array;
                              filename: String;
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          },
                      >;
                  },
              >,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.importSpace",
              Struct<
                  {
                      archive: Struct<
                          {
                              contents: Uint8Array;
                              filename: String;
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          },
                      >;
                      tags: optional<mutable<$Array<String>>>;
                  },
              >,
              Struct<{ newSpaceId: String }>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.joinBySpaceKey",
              Struct<
                  {
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.postMessage",
              Struct<
                  {
                      channel: String;
                      message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.queryCredentials",
              Struct<
                  {
                      noTail: optional<Boolean>;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Stream<
                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.querySpaces",
              Void,
              Stream<
                  Codec<QuerySpacesResponse, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.subscribeMessages",
              Struct<
                  {
                      channel: String;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Stream<
                  Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.updateMemberRole",
              Struct<
                  {
                      memberKey: Codec<
                          PublicKey,
                          Uint8Array<ArrayBufferLike>,
                          never,
                          never,
                      >;
                      newRole: Enum<
                          {
                              ADMIN: number;
                              EDITOR: number;
                              INVALID: number;
                              OWNER: number;
                              READER: number;
                              REMOVED: number;
                          },
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.updateSpace",
              Struct<
                  {
                      edgeReplication: optional<
                          Enum<{ DISABLED: number; ENABLED: number }>,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                      state: optional<
                          Enum<
                              {
                                  INVALID: number;
                                  SPACE_ACTIVE: number;
                                  SPACE_CLOSED: number;
                                  SPACE_CONTROL_ONLY: number;
                                  SPACE_DELETED: number;
                                  SPACE_ERROR: number;
                                  SPACE_INACTIVE: number;
                                  SPACE_INITIALIZING: number;
                                  SPACE_READY: number;
                                  SPACE_REQUIRES_MIGRATION: number;
                              },
                          >,
                      >;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.writeCredentials",
              Struct<
                  {
                      credentials: optional<
                          mutable<
                              $Array<
                                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                              >,
                          >,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >,
      >

    • Annotate the Rpc's above this point with the provided annotations.

      Type Parameters

      • S

      Parameters

      • annotations: Context<S>

      Returns RpcGroup<
          | Rpc<
              "SpacesService.admitContact",
              Struct<
                  {
                      contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                      role: Enum<
                          {
                              ADMIN: number;
                              EDITOR: number;
                              INVALID: number;
                              OWNER: number;
                              READER: number;
                              REMOVED: number;
                          },
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.createEpoch",
              Struct<
                  {
                      automergeRootUrl: optional<String>;
                      migration: optional<
                          Enum<
                              {
                                  FRAGMENT_AUTOMERGE_ROOT: number;
                                  INIT_AUTOMERGE: number;
                                  MIGRATE_REFERENCES_TO_DXN: number;
                                  NONE: number;
                                  PRUNE_AUTOMERGE_ROOT_HISTORY: number;
                                  REPLACE_AUTOMERGE_ROOT: number;
                              },
                          >,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.createSpace",
              Struct<
                  {
                      membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                      tags: optional<mutable<$Array<String>>>;
                  },
              >,
              Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.exportSpace",
              Struct<
                  {
                      format: optional<Enum<{ BINARY: number; JSON: number }>>;
                      spaceId: String;
                  },
              >,
              Struct<
                  {
                      archive: Struct<
                          {
                              contents: Uint8Array;
                              filename: String;
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          },
                      >;
                  },
              >,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.importSpace",
              Struct<
                  {
                      archive: Struct<
                          {
                              contents: Uint8Array;
                              filename: String;
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          },
                      >;
                      tags: optional<mutable<$Array<String>>>;
                  },
              >,
              Struct<{ newSpaceId: String }>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.joinBySpaceKey",
              Struct<
                  {
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.postMessage",
              Struct<
                  {
                      channel: String;
                      message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.queryCredentials",
              Struct<
                  {
                      noTail: optional<Boolean>;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Stream<
                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.querySpaces",
              Void,
              Stream<
                  Codec<QuerySpacesResponse, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.subscribeMessages",
              Struct<
                  {
                      channel: String;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Stream<
                  Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.updateMemberRole",
              Struct<
                  {
                      memberKey: Codec<
                          PublicKey,
                          Uint8Array<ArrayBufferLike>,
                          never,
                          never,
                      >;
                      newRole: Enum<
                          {
                              ADMIN: number;
                              EDITOR: number;
                              INVALID: number;
                              OWNER: number;
                              READER: number;
                              REMOVED: number;
                          },
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.updateSpace",
              Struct<
                  {
                      edgeReplication: optional<
                          Enum<{ DISABLED: number; ENABLED: number }>,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                      state: optional<
                          Enum<
                              {
                                  INVALID: number;
                                  SPACE_ACTIVE: number;
                                  SPACE_CLOSED: number;
                                  SPACE_CONTROL_ONLY: number;
                                  SPACE_DELETED: number;
                                  SPACE_ERROR: number;
                                  SPACE_INACTIVE: number;
                                  SPACE_INITIALIZING: number;
                                  SPACE_READY: number;
                                  SPACE_REQUIRES_MIGRATION: number;
                              },
                          >,
                      >;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.writeCredentials",
              Struct<
                  {
                      credentials: optional<
                          mutable<
                              $Array<
                                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                              >,
                          >,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >,
      >

    • Merge this group with one or more other groups.

      Type Parameters

      • const Groups extends readonly Any[]

      Parameters

      Returns RpcGroup<
          | Rpc<
              "SpacesService.admitContact",
              Struct<
                  {
                      contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                      role: Enum<
                          {
                              ADMIN: number;
                              EDITOR: number;
                              INVALID: number;
                              OWNER: number;
                              READER: number;
                              REMOVED: number;
                          },
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.createEpoch",
              Struct<
                  {
                      automergeRootUrl: optional<String>;
                      migration: optional<
                          Enum<
                              {
                                  FRAGMENT_AUTOMERGE_ROOT: number;
                                  INIT_AUTOMERGE: number;
                                  MIGRATE_REFERENCES_TO_DXN: number;
                                  NONE: number;
                                  PRUNE_AUTOMERGE_ROOT_HISTORY: number;
                                  REPLACE_AUTOMERGE_ROOT: number;
                              },
                          >,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.createSpace",
              Struct<
                  {
                      membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                      tags: optional<mutable<$Array<String>>>;
                  },
              >,
              Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.exportSpace",
              Struct<
                  {
                      format: optional<Enum<{ BINARY: number; JSON: number }>>;
                      spaceId: String;
                  },
              >,
              Struct<
                  {
                      archive: Struct<
                          {
                              contents: Uint8Array;
                              filename: String;
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          },
                      >;
                  },
              >,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.importSpace",
              Struct<
                  {
                      archive: Struct<
                          {
                              contents: Uint8Array;
                              filename: String;
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          },
                      >;
                      tags: optional<mutable<$Array<String>>>;
                  },
              >,
              Struct<{ newSpaceId: String }>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.joinBySpaceKey",
              Struct<
                  {
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.postMessage",
              Struct<
                  {
                      channel: String;
                      message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.queryCredentials",
              Struct<
                  {
                      noTail: optional<Boolean>;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Stream<
                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.querySpaces",
              Void,
              Stream<
                  Codec<QuerySpacesResponse, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.subscribeMessages",
              Struct<
                  {
                      channel: String;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Stream<
                  Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              "SpacesService.updateMemberRole",
              Struct<
                  {
                      memberKey: Codec<
                          PublicKey,
                          Uint8Array<ArrayBufferLike>,
                          never,
                          never,
                      >;
                      newRole: Enum<
                          {
                              ADMIN: number;
                              EDITOR: number;
                              INVALID: number;
                              OWNER: number;
                              READER: number;
                              REMOVED: number;
                          },
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.updateSpace",
              Struct<
                  {
                      edgeReplication: optional<
                          Enum<{ DISABLED: number; ENABLED: number }>,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                      state: optional<
                          Enum<
                              {
                                  INVALID: number;
                                  SPACE_ACTIVE: number;
                                  SPACE_CLOSED: number;
                                  SPACE_CONTROL_ONLY: number;
                                  SPACE_DELETED: number;
                                  SPACE_ERROR: number;
                                  SPACE_INACTIVE: number;
                                  SPACE_INITIALIZING: number;
                                  SPACE_READY: number;
                                  SPACE_REQUIRES_MIGRATION: number;
                              },
                          >,
                      >;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              "SpacesService.writeCredentials",
              Struct<
                  {
                      credentials: optional<
                          mutable<
                              $Array<
                                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                              >,
                          >,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpcs<Groups[number]>,
      >

    • Add middleware to all the procedures added to the group until this point.

      Type Parameters

      • M extends AnyService

      Parameters

      • middleware: M

      Returns RpcGroup<
          | Rpc<
              "SpacesService.admitContact",
              Struct<
                  {
                      contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                      role: Enum<
                          {
                              ADMIN: number;
                              EDITOR: number;
                              INVALID: number;
                              OWNER: number;
                              READER: number;
                              REMOVED: number;
                          },
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              M,
              Requires<M["Identifier"]>,
          >
          | Rpc<
              "SpacesService.createEpoch",
              Struct<
                  {
                      automergeRootUrl: optional<String>;
                      migration: optional<
                          Enum<
                              {
                                  FRAGMENT_AUTOMERGE_ROOT: number;
                                  INIT_AUTOMERGE: number;
                                  MIGRATE_REFERENCES_TO_DXN: number;
                                  NONE: number;
                                  PRUNE_AUTOMERGE_ROOT_HISTORY: number;
                                  REPLACE_AUTOMERGE_ROOT: number;
                              },
                          >,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              M,
              Requires<M["Identifier"]>,
          >
          | Rpc<
              "SpacesService.createSpace",
              Struct<
                  {
                      membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                      tags: optional<mutable<$Array<String>>>;
                  },
              >,
              Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              M,
              Requires<M["Identifier"]>,
          >
          | Rpc<
              "SpacesService.exportSpace",
              Struct<
                  {
                      format: optional<Enum<{ BINARY: number; JSON: number }>>;
                      spaceId: String;
                  },
              >,
              Struct<
                  {
                      archive: Struct<
                          {
                              contents: Uint8Array;
                              filename: String;
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          },
                      >;
                  },
              >,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              M,
              Requires<M["Identifier"]>,
          >
          | Rpc<
              "SpacesService.importSpace",
              Struct<
                  {
                      archive: Struct<
                          {
                              contents: Uint8Array;
                              filename: String;
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          },
                      >;
                      tags: optional<mutable<$Array<String>>>;
                  },
              >,
              Struct<{ newSpaceId: String }>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              M,
              Requires<M["Identifier"]>,
          >
          | Rpc<
              "SpacesService.joinBySpaceKey",
              Struct<
                  {
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              M,
              Requires<M["Identifier"]>,
          >
          | Rpc<
              "SpacesService.postMessage",
              Struct<
                  {
                      channel: String;
                      message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              M,
              Requires<M["Identifier"]>,
          >
          | Rpc<
              "SpacesService.queryCredentials",
              Struct<
                  {
                      noTail: optional<Boolean>;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Stream<
                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              M,
              Requires<M["Identifier"]>,
          >
          | Rpc<
              "SpacesService.querySpaces",
              Void,
              Stream<
                  Codec<QuerySpacesResponse, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              M,
              Requires<M["Identifier"]>,
          >
          | Rpc<
              "SpacesService.subscribeMessages",
              Struct<
                  {
                      channel: String;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Stream<
                  Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              M,
              Requires<M["Identifier"]>,
          >
          | Rpc<
              "SpacesService.updateMemberRole",
              Struct<
                  {
                      memberKey: Codec<
                          PublicKey,
                          Uint8Array<ArrayBufferLike>,
                          never,
                          never,
                      >;
                      newRole: Enum<
                          {
                              ADMIN: number;
                              EDITOR: number;
                              INVALID: number;
                              OWNER: number;
                              READER: number;
                              REMOVED: number;
                          },
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              M,
              Requires<M["Identifier"]>,
          >
          | Rpc<
              "SpacesService.updateSpace",
              Struct<
                  {
                      edgeReplication: optional<
                          Enum<{ DISABLED: number; ENABLED: number }>,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                      state: optional<
                          Enum<
                              {
                                  INVALID: number;
                                  SPACE_ACTIVE: number;
                                  SPACE_CLOSED: number;
                                  SPACE_CONTROL_ONLY: number;
                                  SPACE_DELETED: number;
                                  SPACE_ERROR: number;
                                  SPACE_INACTIVE: number;
                                  SPACE_INITIALIZING: number;
                                  SPACE_READY: number;
                                  SPACE_REQUIRES_MIGRATION: number;
                              },
                          >,
                      >;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              M,
              Requires<M["Identifier"]>,
          >
          | Rpc<
              "SpacesService.writeCredentials",
              Struct<
                  {
                      credentials: optional<
                          mutable<
                              $Array<
                                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                              >,
                          >,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              M,
              Requires<M["Identifier"]>,
          >,
      >

    • Type Parameters

      • const Handlers extends HandlersFrom<
            | Rpc<
                "SpacesService.admitContact",
                Struct<
                    {
                        contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                        role: Enum<
                            {
                                ADMIN: number;
                                EDITOR: number;
                                INVALID: number;
                                OWNER: number;
                                READER: number;
                                REMOVED: number;
                            },
                        >;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Void,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.createEpoch",
                Struct<
                    {
                        automergeRootUrl: optional<String>;
                        migration: optional<
                            Enum<
                                {
                                    FRAGMENT_AUTOMERGE_ROOT: number;
                                    INIT_AUTOMERGE: number;
                                    MIGRATE_REFERENCES_TO_DXN: number;
                                    NONE: number;
                                    PRUNE_AUTOMERGE_ROOT_HISTORY: number;
                                    REPLACE_AUTOMERGE_ROOT: number;
                                },
                            >,
                        >;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.createSpace",
                Struct<
                    {
                        membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                        tags: optional<mutable<$Array<String>>>;
                    },
                >,
                Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.exportSpace",
                Struct<
                    {
                        format: optional<Enum<{ BINARY: number; JSON: number }>>;
                        spaceId: String;
                    },
                >,
                Struct<
                    {
                        archive: Struct<
                            {
                                contents: Uint8Array;
                                filename: String;
                                format: optional<Enum<{ BINARY: number; JSON: number }>>;
                            },
                        >;
                    },
                >,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.importSpace",
                Struct<
                    {
                        archive: Struct<
                            {
                                contents: Uint8Array;
                                filename: String;
                                format: optional<Enum<{ BINARY: number; JSON: number }>>;
                            },
                        >;
                        tags: optional<mutable<$Array<String>>>;
                    },
                >,
                Struct<{ newSpaceId: String }>,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.joinBySpaceKey",
                Struct<
                    {
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.postMessage",
                Struct<
                    {
                        channel: String;
                        message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Void,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.queryCredentials",
                Struct<
                    {
                        noTail: optional<Boolean>;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Stream<
                    Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                    Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                >,
                Never,
                never,
                never,
            >
            | Rpc<
                "SpacesService.querySpaces",
                Void,
                Stream<
                    Codec<QuerySpacesResponse, Uint8Array<ArrayBufferLike>, never, never>,
                    Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                >,
                Never,
                never,
                never,
            >
            | Rpc<
                "SpacesService.subscribeMessages",
                Struct<
                    {
                        channel: String;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Stream<
                    Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                    Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                >,
                Never,
                never,
                never,
            >
            | Rpc<
                "SpacesService.updateMemberRole",
                Struct<
                    {
                        memberKey: Codec<
                            PublicKey,
                            Uint8Array<ArrayBufferLike>,
                            never,
                            never,
                        >;
                        newRole: Enum<
                            {
                                ADMIN: number;
                                EDITOR: number;
                                INVALID: number;
                                OWNER: number;
                                READER: number;
                                REMOVED: number;
                            },
                        >;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Void,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.updateSpace",
                Struct<
                    {
                        edgeReplication: optional<
                            Enum<{ DISABLED: number; ENABLED: number }>,
                        >;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                        state: optional<
                            Enum<
                                {
                                    INVALID: number;
                                    SPACE_ACTIVE: number;
                                    SPACE_CLOSED: number;
                                    SPACE_CONTROL_ONLY: number;
                                    SPACE_DELETED: number;
                                    SPACE_ERROR: number;
                                    SPACE_INACTIVE: number;
                                    SPACE_INITIALIZING: number;
                                    SPACE_READY: number;
                                    SPACE_REQUIRES_MIGRATION: number;
                                },
                            >,
                        >;
                    },
                >,
                Void,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.writeCredentials",
                Struct<
                    {
                        credentials: optional<
                            mutable<
                                $Array<
                                    Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                                >,
                            >,
                        >;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Void,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >,
        >

      Parameters

      Returns Handlers

    • Omit one or more procedures from the group.

      Type Parameters

      • const Tags extends readonly (
            | "SpacesService.admitContact"
            | "SpacesService.createEpoch"
            | "SpacesService.createSpace"
            | "SpacesService.exportSpace"
            | "SpacesService.importSpace"
            | "SpacesService.joinBySpaceKey"
            | "SpacesService.postMessage"
            | "SpacesService.queryCredentials"
            | "SpacesService.querySpaces"
            | "SpacesService.subscribeMessages"
            | "SpacesService.updateMemberRole"
            | "SpacesService.updateSpace"
            | "SpacesService.writeCredentials"
        )[]

      Parameters

      Returns RpcGroup<
          | Exclude<
              Rpc<
                  "SpacesService.admitContact",
                  Struct<
                      {
                          contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                          role: Enum<
                              {
                                  ADMIN: number;
                                  EDITOR: number;
                                  INVALID: number;
                                  OWNER: number;
                                  READER: number;
                                  REMOVED: number;
                              },
                          >;
                          spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                      },
                  >,
                  Void,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                  never,
                  never,
              >,
              { _tag: Tags[number] },
          >
          | Exclude<
              Rpc<
                  "SpacesService.createEpoch",
                  Struct<
                      {
                          automergeRootUrl: optional<String>;
                          migration: optional<
                              Enum<
                                  {
                                      FRAGMENT_AUTOMERGE_ROOT: number;
                                      INIT_AUTOMERGE: number;
                                      MIGRATE_REFERENCES_TO_DXN: number;
                                      NONE: number;
                                      PRUNE_AUTOMERGE_ROOT_HISTORY: number;
                                      REPLACE_AUTOMERGE_ROOT: number;
                                  },
                              >,
                          >;
                          spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                      },
                  >,
                  Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                  never,
                  never,
              >,
              { _tag: Tags[number] },
          >
          | Exclude<
              Rpc<
                  "SpacesService.createSpace",
                  Struct<
                      {
                          membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                          tags: optional<mutable<$Array<String>>>;
                      },
                  >,
                  Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                  never,
                  never,
              >,
              { _tag: Tags[number] },
          >
          | Exclude<
              Rpc<
                  "SpacesService.exportSpace",
                  Struct<
                      {
                          format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          spaceId: String;
                      },
                  >,
                  Struct<
                      {
                          archive: Struct<
                              {
                                  contents: Uint8Array;
                                  filename: String;
                                  format: optional<Enum<{ BINARY: ...; JSON: ... }>>;
                              },
                          >;
                      },
                  >,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                  never,
                  never,
              >,
              { _tag: Tags[number] },
          >
          | Exclude<
              Rpc<
                  "SpacesService.importSpace",
                  Struct<
                      {
                          archive: Struct<
                              {
                                  contents: Uint8Array;
                                  filename: String;
                                  format: optional<Enum<{ BINARY: ...; JSON: ... }>>;
                              },
                          >;
                          tags: optional<mutable<$Array<String>>>;
                      },
                  >,
                  Struct<{ newSpaceId: String }>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                  never,
                  never,
              >,
              { _tag: Tags[number] },
          >
          | Exclude<
              Rpc<
                  "SpacesService.joinBySpaceKey",
                  Struct<
                      {
                          spaceKey: Codec<
                              PublicKey,
                              Uint8Array<ArrayBufferLike>,
                              never,
                              never,
                          >;
                      },
                  >,
                  Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                  never,
                  never,
              >,
              { _tag: Tags[number] },
          >
          | Exclude<
              Rpc<
                  "SpacesService.postMessage",
                  Struct<
                      {
                          channel: String;
                          message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                          spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                      },
                  >,
                  Void,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                  never,
                  never,
              >,
              { _tag: Tags[number] },
          >
          | Exclude<
              Rpc<
                  "SpacesService.queryCredentials",
                  Struct<
                      {
                          noTail: optional<Boolean>;
                          spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                      },
                  >,
                  Stream<
                      Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                  >,
                  Never,
                  never,
                  never,
              >,
              { _tag: Tags[number] },
          >
          | Exclude<
              Rpc<
                  "SpacesService.querySpaces",
                  Void,
                  Stream<
                      Codec<QuerySpacesResponse, Uint8Array<ArrayBufferLike>, never, never>,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                  >,
                  Never,
                  never,
                  never,
              >,
              { _tag: Tags[number] },
          >
          | Exclude<
              Rpc<
                  "SpacesService.subscribeMessages",
                  Struct<
                      {
                          channel: String;
                          spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                      },
                  >,
                  Stream<
                      Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                  >,
                  Never,
                  never,
                  never,
              >,
              { _tag: Tags[number] },
          >
          | Exclude<
              Rpc<
                  "SpacesService.updateMemberRole",
                  Struct<
                      {
                          memberKey: Codec<
                              PublicKey,
                              Uint8Array<ArrayBufferLike>,
                              never,
                              never,
                          >;
                          newRole: Enum<
                              {
                                  ADMIN: number;
                                  EDITOR: number;
                                  INVALID: number;
                                  OWNER: number;
                                  READER: number;
                                  REMOVED: number;
                              },
                          >;
                          spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                      },
                  >,
                  Void,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                  never,
                  never,
              >,
              { _tag: Tags[number] },
          >
          | Exclude<
              Rpc<
                  "SpacesService.updateSpace",
                  Struct<
                      {
                          edgeReplication: optional<
                              Enum<{ DISABLED: number; ENABLED: number }>,
                          >;
                          spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          state: optional<
                              Enum<
                                  {
                                      INVALID: number;
                                      SPACE_ACTIVE: number;
                                      SPACE_CLOSED: number;
                                      SPACE_CONTROL_ONLY: number;
                                      SPACE_DELETED: number;
                                      SPACE_ERROR: number;
                                      SPACE_INACTIVE: number;
                                      SPACE_INITIALIZING: number;
                                      SPACE_READY: number;
                                      SPACE_REQUIRES_MIGRATION: number;
                                  },
                              >,
                          >;
                      },
                  >,
                  Void,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                  never,
                  never,
              >,
              { _tag: Tags[number] },
          >
          | Exclude<
              Rpc<
                  "SpacesService.writeCredentials",
                  Struct<
                      {
                          credentials: optional<
                              mutable<$Array<Codec<Credential, Uint8Array<(...)>, never, never>>>,
                          >;
                          spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                      },
                  >,
                  Void,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                  never,
                  never,
              >,
              { _tag: Tags[number] },
          >,
      >

    • Type Parameters

      • A

      Parameters

      • this: A

      Returns A

    • Type Parameters

      • A
      • B = never

      Parameters

      • this: A
      • ab: (_: A) => B

      Returns B

    • Type Parameters

      • A
      • B = never
      • C = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C

      Returns C

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D

      Returns D

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E

      Returns E

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F

      Returns F

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never
      • G = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G

      Returns G

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never
      • G = never
      • H = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H

      Returns H

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never
      • G = never
      • H = never
      • I = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I

      Returns I

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never
      • G = never
      • H = never
      • I = never
      • J = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J

      Returns J

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never
      • G = never
      • H = never
      • I = never
      • J = never
      • K = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K

      Returns K

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never
      • G = never
      • H = never
      • I = never
      • J = never
      • K = never
      • L = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L

      Returns L

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never
      • G = never
      • H = never
      • I = never
      • J = never
      • K = never
      • L = never
      • M = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M

      Returns M

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never
      • G = never
      • H = never
      • I = never
      • J = never
      • K = never
      • L = never
      • M = never
      • N = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N

      Returns N

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never
      • G = never
      • H = never
      • I = never
      • J = never
      • K = never
      • L = never
      • M = never
      • N = never
      • O = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N
      • no: (_: N) => O

      Returns O

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never
      • G = never
      • H = never
      • I = never
      • J = never
      • K = never
      • L = never
      • M = never
      • N = never
      • O = never
      • P = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N
      • no: (_: N) => O
      • op: (_: O) => P

      Returns P

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never
      • G = never
      • H = never
      • I = never
      • J = never
      • K = never
      • L = never
      • M = never
      • N = never
      • O = never
      • P = never
      • Q = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N
      • no: (_: N) => O
      • op: (_: O) => P
      • pq: (_: P) => Q

      Returns Q

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never
      • G = never
      • H = never
      • I = never
      • J = never
      • K = never
      • L = never
      • M = never
      • N = never
      • O = never
      • P = never
      • Q = never
      • R = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N
      • no: (_: N) => O
      • op: (_: O) => P
      • pq: (_: P) => Q
      • qr: (_: Q) => R

      Returns R

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never
      • G = never
      • H = never
      • I = never
      • J = never
      • K = never
      • L = never
      • M = never
      • N = never
      • O = never
      • P = never
      • Q = never
      • R = never
      • S = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N
      • no: (_: N) => O
      • op: (_: O) => P
      • pq: (_: P) => Q
      • qr: (_: Q) => R
      • rs: (_: R) => S

      Returns S

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never
      • G = never
      • H = never
      • I = never
      • J = never
      • K = never
      • L = never
      • M = never
      • N = never
      • O = never
      • P = never
      • Q = never
      • R = never
      • S = never
      • T = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N
      • no: (_: N) => O
      • op: (_: O) => P
      • pq: (_: P) => Q
      • qr: (_: Q) => R
      • rs: (_: R) => S
      • st: (_: S) => T

      Returns T

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never
      • G = never
      • H = never
      • I = never
      • J = never
      • K = never
      • L = never
      • M = never
      • N = never
      • O = never
      • P = never
      • Q = never
      • R = never
      • S = never
      • T = never
      • U = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N
      • no: (_: N) => O
      • op: (_: O) => P
      • pq: (_: P) => Q
      • qr: (_: Q) => R
      • rs: (_: R) => S
      • st: (_: S) => T
      • tu: (_: T) => U

      Returns U

    • Type Parameters

      • A
      • B = never
      • C = never
      • D = never
      • E = never
      • F = never
      • G = never
      • H = never
      • I = never
      • J = never
      • K = never
      • L = never
      • M = never
      • N = never
      • O = never
      • P = never
      • Q = never
      • R = never
      • S = never
      • T = never
      • U = never

      Parameters

      • this: A
      • ab: (_: A) => B
      • bc: (_: B) => C
      • cd: (_: C) => D
      • de: (_: D) => E
      • ef: (_: E) => F
      • fg: (_: F) => G
      • gh: (_: G) => H
      • hi: (_: H) => I
      • ij: (_: I) => J
      • jk: (_: J) => K
      • kl: (_: K) => L
      • lm: (_: L) => M
      • mn: (_: M) => N
      • no: (_: N) => O
      • op: (_: O) => P
      • pq: (_: P) => Q
      • qr: (_: Q) => R
      • rs: (_: R) => S
      • st: (_: S) => T
      • tu: (_: T) => U

      Returns U

    • Add a prefix to the procedures in this group, returning a new group

      Type Parameters

      • const Prefix extends string

      Parameters

      Returns RpcGroup<
          | Rpc<
              `${Prefix}SpacesService.admitContact`,
              Struct<
                  {
                      contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                      role: Enum<
                          {
                              ADMIN: number;
                              EDITOR: number;
                              INVALID: number;
                              OWNER: number;
                              READER: number;
                              REMOVED: number;
                          },
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              `${Prefix}SpacesService.createEpoch`,
              Struct<
                  {
                      automergeRootUrl: optional<String>;
                      migration: optional<
                          Enum<
                              {
                                  FRAGMENT_AUTOMERGE_ROOT: number;
                                  INIT_AUTOMERGE: number;
                                  MIGRATE_REFERENCES_TO_DXN: number;
                                  NONE: number;
                                  PRUNE_AUTOMERGE_ROOT_HISTORY: number;
                                  REPLACE_AUTOMERGE_ROOT: number;
                              },
                          >,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              `${Prefix}SpacesService.createSpace`,
              Struct<
                  {
                      membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                      tags: optional<mutable<$Array<String>>>;
                  },
              >,
              Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              `${Prefix}SpacesService.exportSpace`,
              Struct<
                  {
                      format: optional<Enum<{ BINARY: number; JSON: number }>>;
                      spaceId: String;
                  },
              >,
              Struct<
                  {
                      archive: Struct<
                          {
                              contents: Uint8Array;
                              filename: String;
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          },
                      >;
                  },
              >,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              `${Prefix}SpacesService.importSpace`,
              Struct<
                  {
                      archive: Struct<
                          {
                              contents: Uint8Array;
                              filename: String;
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                          },
                      >;
                      tags: optional<mutable<$Array<String>>>;
                  },
              >,
              Struct<{ newSpaceId: String }>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              `${Prefix}SpacesService.joinBySpaceKey`,
              Struct<
                  {
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              `${Prefix}SpacesService.postMessage`,
              Struct<
                  {
                      channel: String;
                      message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              `${Prefix}SpacesService.queryCredentials`,
              Struct<
                  {
                      noTail: optional<Boolean>;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Stream<
                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              `${Prefix}SpacesService.querySpaces`,
              Void,
              Stream<
                  Codec<QuerySpacesResponse, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              `${Prefix}SpacesService.subscribeMessages`,
              Struct<
                  {
                      channel: String;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Stream<
                  Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                  Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              >,
              Never,
              never,
              never,
          >
          | Rpc<
              `${Prefix}SpacesService.updateMemberRole`,
              Struct<
                  {
                      memberKey: Codec<
                          PublicKey,
                          Uint8Array<ArrayBufferLike>,
                          never,
                          never,
                      >;
                      newRole: Enum<
                          {
                              ADMIN: number;
                              EDITOR: number;
                              INVALID: number;
                              OWNER: number;
                              READER: number;
                              REMOVED: number;
                          },
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              `${Prefix}SpacesService.updateSpace`,
              Struct<
                  {
                      edgeReplication: optional<
                          Enum<{ DISABLED: number; ENABLED: number }>,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                      state: optional<
                          Enum<
                              {
                                  INVALID: number;
                                  SPACE_ACTIVE: number;
                                  SPACE_CLOSED: number;
                                  SPACE_CONTROL_ONLY: number;
                                  SPACE_DELETED: number;
                                  SPACE_ERROR: number;
                                  SPACE_INACTIVE: number;
                                  SPACE_INITIALIZING: number;
                                  SPACE_READY: number;
                                  SPACE_REQUIRES_MIGRATION: number;
                              },
                          >,
                      >;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >
          | Rpc<
              `${Prefix}SpacesService.writeCredentials`,
              Struct<
                  {
                      credentials: optional<
                          mutable<
                              $Array<
                                  Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                              >,
                          >,
                      >;
                      spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                  },
              >,
              Void,
              Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
              never,
              never,
          >,
      >

    • Implement the handlers for the procedures in this group, returning a context object.

      Type Parameters

      • Handlers extends HandlersFrom<
            | Rpc<
                "SpacesService.admitContact",
                Struct<
                    {
                        contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                        role: Enum<
                            {
                                ADMIN: number;
                                EDITOR: number;
                                INVALID: number;
                                OWNER: number;
                                READER: number;
                                REMOVED: number;
                            },
                        >;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Void,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.createEpoch",
                Struct<
                    {
                        automergeRootUrl: optional<String>;
                        migration: optional<
                            Enum<
                                {
                                    FRAGMENT_AUTOMERGE_ROOT: number;
                                    INIT_AUTOMERGE: number;
                                    MIGRATE_REFERENCES_TO_DXN: number;
                                    NONE: number;
                                    PRUNE_AUTOMERGE_ROOT_HISTORY: number;
                                    REPLACE_AUTOMERGE_ROOT: number;
                                },
                            >,
                        >;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.createSpace",
                Struct<
                    {
                        membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                        tags: optional<mutable<$Array<String>>>;
                    },
                >,
                Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.exportSpace",
                Struct<
                    {
                        format: optional<Enum<{ BINARY: number; JSON: number }>>;
                        spaceId: String;
                    },
                >,
                Struct<
                    {
                        archive: Struct<
                            {
                                contents: Uint8Array;
                                filename: String;
                                format: optional<Enum<{ BINARY: number; JSON: number }>>;
                            },
                        >;
                    },
                >,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.importSpace",
                Struct<
                    {
                        archive: Struct<
                            {
                                contents: Uint8Array;
                                filename: String;
                                format: optional<Enum<{ BINARY: number; JSON: number }>>;
                            },
                        >;
                        tags: optional<mutable<$Array<String>>>;
                    },
                >,
                Struct<{ newSpaceId: String }>,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.joinBySpaceKey",
                Struct<
                    {
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.postMessage",
                Struct<
                    {
                        channel: String;
                        message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Void,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.queryCredentials",
                Struct<
                    {
                        noTail: optional<Boolean>;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Stream<
                    Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                    Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                >,
                Never,
                never,
                never,
            >
            | Rpc<
                "SpacesService.querySpaces",
                Void,
                Stream<
                    Codec<QuerySpacesResponse, Uint8Array<ArrayBufferLike>, never, never>,
                    Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                >,
                Never,
                never,
                never,
            >
            | Rpc<
                "SpacesService.subscribeMessages",
                Struct<
                    {
                        channel: String;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Stream<
                    Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                    Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                >,
                Never,
                never,
                never,
            >
            | Rpc<
                "SpacesService.updateMemberRole",
                Struct<
                    {
                        memberKey: Codec<
                            PublicKey,
                            Uint8Array<ArrayBufferLike>,
                            never,
                            never,
                        >;
                        newRole: Enum<
                            {
                                ADMIN: number;
                                EDITOR: number;
                                INVALID: number;
                                OWNER: number;
                                READER: number;
                                REMOVED: number;
                            },
                        >;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Void,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.updateSpace",
                Struct<
                    {
                        edgeReplication: optional<
                            Enum<{ DISABLED: number; ENABLED: number }>,
                        >;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                        state: optional<
                            Enum<
                                {
                                    INVALID: number;
                                    SPACE_ACTIVE: number;
                                    SPACE_CLOSED: number;
                                    SPACE_CONTROL_ONLY: number;
                                    SPACE_DELETED: number;
                                    SPACE_ERROR: number;
                                    SPACE_INACTIVE: number;
                                    SPACE_INITIALIZING: number;
                                    SPACE_READY: number;
                                    SPACE_REQUIRES_MIGRATION: number;
                                },
                            >,
                        >;
                    },
                >,
                Void,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.writeCredentials",
                Struct<
                    {
                        credentials: optional<
                            mutable<
                                $Array<
                                    Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                                >,
                            >,
                        >;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Void,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >,
        >
      • EX = never
      • RX = never

      Parameters

      Returns Effect<
          Context<
              | Handler<"SpacesService.admitContact">
              | Handler<"SpacesService.createEpoch">
              | Handler<"SpacesService.createSpace">
              | Handler<"SpacesService.exportSpace">
              | Handler<"SpacesService.importSpace">
              | Handler<"SpacesService.joinBySpaceKey">
              | Handler<"SpacesService.postMessage">
              | Handler<"SpacesService.queryCredentials">
              | Handler<"SpacesService.querySpaces">
              | Handler<"SpacesService.subscribeMessages">
              | Handler<"SpacesService.updateMemberRole">
              | Handler<"SpacesService.updateSpace">
              | Handler<"SpacesService.writeCredentials">,
          >,
          EX,

              | RX
              | HandlersServices<
                  | Rpc<
                      "SpacesService.admitContact",
                      Struct<
                          {
                              contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                              role: Enum<
                                  {
                                      ADMIN: number;
                                      EDITOR: number;
                                      INVALID: number;
                                      OWNER: number;
                                      READER: number;
                                      REMOVED: number;
                                  },
                              >;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Void,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.createEpoch",
                      Struct<
                          {
                              automergeRootUrl: optional<String>;
                              migration: optional<
                                  Enum<
                                      {
                                          FRAGMENT_AUTOMERGE_ROOT: number;
                                          INIT_AUTOMERGE: number;
                                          MIGRATE_REFERENCES_TO_DXN: number;
                                          NONE: number;
                                          PRUNE_AUTOMERGE_ROOT_HISTORY: number;
                                          REPLACE_AUTOMERGE_ROOT: number;
                                      },
                                  >,
                              >;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.createSpace",
                      Struct<
                          {
                              membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                              tags: optional<mutable<$Array<String>>>;
                          },
                      >,
                      Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.exportSpace",
                      Struct<
                          {
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                              spaceId: String;
                          },
                      >,
                      Struct<
                          {
                              archive: Struct<
                                  {
                                      contents: Uint8Array;
                                      filename: String;
                                      format: optional<Enum<(...)>>;
                                  },
                              >;
                          },
                      >,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.importSpace",
                      Struct<
                          {
                              archive: Struct<
                                  {
                                      contents: Uint8Array;
                                      filename: String;
                                      format: optional<Enum<(...)>>;
                                  },
                              >;
                              tags: optional<mutable<$Array<String>>>;
                          },
                      >,
                      Struct<{ newSpaceId: String }>,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.joinBySpaceKey",
                      Struct<
                          {
                              spaceKey: Codec<
                                  PublicKey,
                                  Uint8Array<ArrayBufferLike>,
                                  never,
                                  never,
                              >;
                          },
                      >,
                      Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.postMessage",
                      Struct<
                          {
                              channel: String;
                              message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Void,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.queryCredentials",
                      Struct<
                          {
                              noTail: optional<Boolean>;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Stream<
                          Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      >,
                      Never,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.querySpaces",
                      Void,
                      Stream<
                          Codec<
                              QuerySpacesResponse,
                              Uint8Array<ArrayBufferLike>,
                              never,
                              never,
                          >,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      >,
                      Never,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.subscribeMessages",
                      Struct<
                          {
                              channel: String;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Stream<
                          Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      >,
                      Never,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.updateMemberRole",
                      Struct<
                          {
                              memberKey: Codec<
                                  PublicKey,
                                  Uint8Array<ArrayBufferLike>,
                                  never,
                                  never,
                              >;
                              newRole: Enum<
                                  {
                                      ADMIN: number;
                                      EDITOR: number;
                                      INVALID: number;
                                      OWNER: number;
                                      READER: number;
                                      REMOVED: number;
                                  },
                              >;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Void,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.updateSpace",
                      Struct<
                          {
                              edgeReplication: optional<
                                  Enum<{ DISABLED: number; ENABLED: number }>,
                              >;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                              state: optional<
                                  Enum<
                                      {
                                          INVALID: number;
                                          SPACE_ACTIVE: number;
                                          SPACE_CLOSED: number;
                                          SPACE_CONTROL_ONLY: number;
                                          SPACE_DELETED: number;
                                          SPACE_ERROR: number;
                                          SPACE_INACTIVE: number;
                                          SPACE_INITIALIZING: number;
                                          SPACE_READY: number;
                                          SPACE_REQUIRES_MIGRATION: number;
                                      },
                                  >,
                              >;
                          },
                      >,
                      Void,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.writeCredentials",
                      Struct<
                          {
                              credentials: optional<
                                  mutable<$Array<Codec<(...), (...), (...), (...)>>>,
                              >;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Void,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >,
                  Handlers,
              >,
      >

    • Implement the handlers for the procedures in this group.

      Type Parameters

      • Handlers extends HandlersFrom<
            | Rpc<
                "SpacesService.admitContact",
                Struct<
                    {
                        contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                        role: Enum<
                            {
                                ADMIN: number;
                                EDITOR: number;
                                INVALID: number;
                                OWNER: number;
                                READER: number;
                                REMOVED: number;
                            },
                        >;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Void,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.createEpoch",
                Struct<
                    {
                        automergeRootUrl: optional<String>;
                        migration: optional<
                            Enum<
                                {
                                    FRAGMENT_AUTOMERGE_ROOT: number;
                                    INIT_AUTOMERGE: number;
                                    MIGRATE_REFERENCES_TO_DXN: number;
                                    NONE: number;
                                    PRUNE_AUTOMERGE_ROOT_HISTORY: number;
                                    REPLACE_AUTOMERGE_ROOT: number;
                                },
                            >,
                        >;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.createSpace",
                Struct<
                    {
                        membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                        tags: optional<mutable<$Array<String>>>;
                    },
                >,
                Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.exportSpace",
                Struct<
                    {
                        format: optional<Enum<{ BINARY: number; JSON: number }>>;
                        spaceId: String;
                    },
                >,
                Struct<
                    {
                        archive: Struct<
                            {
                                contents: Uint8Array;
                                filename: String;
                                format: optional<Enum<{ BINARY: number; JSON: number }>>;
                            },
                        >;
                    },
                >,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.importSpace",
                Struct<
                    {
                        archive: Struct<
                            {
                                contents: Uint8Array;
                                filename: String;
                                format: optional<Enum<{ BINARY: number; JSON: number }>>;
                            },
                        >;
                        tags: optional<mutable<$Array<String>>>;
                    },
                >,
                Struct<{ newSpaceId: String }>,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.joinBySpaceKey",
                Struct<
                    {
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.postMessage",
                Struct<
                    {
                        channel: String;
                        message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Void,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.queryCredentials",
                Struct<
                    {
                        noTail: optional<Boolean>;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Stream<
                    Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                    Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                >,
                Never,
                never,
                never,
            >
            | Rpc<
                "SpacesService.querySpaces",
                Void,
                Stream<
                    Codec<QuerySpacesResponse, Uint8Array<ArrayBufferLike>, never, never>,
                    Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                >,
                Never,
                never,
                never,
            >
            | Rpc<
                "SpacesService.subscribeMessages",
                Struct<
                    {
                        channel: String;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Stream<
                    Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                    Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                >,
                Never,
                never,
                never,
            >
            | Rpc<
                "SpacesService.updateMemberRole",
                Struct<
                    {
                        memberKey: Codec<
                            PublicKey,
                            Uint8Array<ArrayBufferLike>,
                            never,
                            never,
                        >;
                        newRole: Enum<
                            {
                                ADMIN: number;
                                EDITOR: number;
                                INVALID: number;
                                OWNER: number;
                                READER: number;
                                REMOVED: number;
                            },
                        >;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Void,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.updateSpace",
                Struct<
                    {
                        edgeReplication: optional<
                            Enum<{ DISABLED: number; ENABLED: number }>,
                        >;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                        state: optional<
                            Enum<
                                {
                                    INVALID: number;
                                    SPACE_ACTIVE: number;
                                    SPACE_CLOSED: number;
                                    SPACE_CONTROL_ONLY: number;
                                    SPACE_DELETED: number;
                                    SPACE_ERROR: number;
                                    SPACE_INACTIVE: number;
                                    SPACE_INITIALIZING: number;
                                    SPACE_READY: number;
                                    SPACE_REQUIRES_MIGRATION: number;
                                },
                            >,
                        >;
                    },
                >,
                Void,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >
            | Rpc<
                "SpacesService.writeCredentials",
                Struct<
                    {
                        credentials: optional<
                            mutable<
                                $Array<
                                    Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                                >,
                            >,
                        >;
                        spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                    },
                >,
                Void,
                Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                never,
                never,
            >,
        >
      • EX = never
      • RX = never

      Parameters

      Returns Layer<
          | Handler<"SpacesService.admitContact">
          | Handler<"SpacesService.createEpoch">
          | Handler<"SpacesService.createSpace">
          | Handler<"SpacesService.exportSpace">
          | Handler<"SpacesService.importSpace">
          | Handler<"SpacesService.joinBySpaceKey">
          | Handler<"SpacesService.postMessage">
          | Handler<"SpacesService.queryCredentials">
          | Handler<"SpacesService.querySpaces">
          | Handler<"SpacesService.subscribeMessages">
          | Handler<"SpacesService.updateMemberRole">
          | Handler<"SpacesService.updateSpace">
          | Handler<"SpacesService.writeCredentials">,
          EX,

              | Exclude<RX, Scope>
              | HandlersServices<
                  | Rpc<
                      "SpacesService.admitContact",
                      Struct<
                          {
                              contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                              role: Enum<
                                  {
                                      ADMIN: number;
                                      EDITOR: number;
                                      INVALID: number;
                                      OWNER: number;
                                      READER: number;
                                      REMOVED: number;
                                  },
                              >;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Void,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.createEpoch",
                      Struct<
                          {
                              automergeRootUrl: optional<String>;
                              migration: optional<
                                  Enum<
                                      {
                                          FRAGMENT_AUTOMERGE_ROOT: number;
                                          INIT_AUTOMERGE: number;
                                          MIGRATE_REFERENCES_TO_DXN: number;
                                          NONE: number;
                                          PRUNE_AUTOMERGE_ROOT_HISTORY: number;
                                          REPLACE_AUTOMERGE_ROOT: number;
                                      },
                                  >,
                              >;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.createSpace",
                      Struct<
                          {
                              membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                              tags: optional<mutable<$Array<String>>>;
                          },
                      >,
                      Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.exportSpace",
                      Struct<
                          {
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                              spaceId: String;
                          },
                      >,
                      Struct<
                          {
                              archive: Struct<
                                  {
                                      contents: Uint8Array;
                                      filename: String;
                                      format: optional<Enum<(...)>>;
                                  },
                              >;
                          },
                      >,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.importSpace",
                      Struct<
                          {
                              archive: Struct<
                                  {
                                      contents: Uint8Array;
                                      filename: String;
                                      format: optional<Enum<(...)>>;
                                  },
                              >;
                              tags: optional<mutable<$Array<String>>>;
                          },
                      >,
                      Struct<{ newSpaceId: String }>,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.joinBySpaceKey",
                      Struct<
                          {
                              spaceKey: Codec<
                                  PublicKey,
                                  Uint8Array<ArrayBufferLike>,
                                  never,
                                  never,
                              >;
                          },
                      >,
                      Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.postMessage",
                      Struct<
                          {
                              channel: String;
                              message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Void,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.queryCredentials",
                      Struct<
                          {
                              noTail: optional<Boolean>;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Stream<
                          Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      >,
                      Never,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.querySpaces",
                      Void,
                      Stream<
                          Codec<
                              QuerySpacesResponse,
                              Uint8Array<ArrayBufferLike>,
                              never,
                              never,
                          >,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      >,
                      Never,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.subscribeMessages",
                      Struct<
                          {
                              channel: String;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Stream<
                          Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      >,
                      Never,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.updateMemberRole",
                      Struct<
                          {
                              memberKey: Codec<
                                  PublicKey,
                                  Uint8Array<ArrayBufferLike>,
                                  never,
                                  never,
                              >;
                              newRole: Enum<
                                  {
                                      ADMIN: number;
                                      EDITOR: number;
                                      INVALID: number;
                                      OWNER: number;
                                      READER: number;
                                      REMOVED: number;
                                  },
                              >;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Void,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.updateSpace",
                      Struct<
                          {
                              edgeReplication: optional<
                                  Enum<{ DISABLED: number; ENABLED: number }>,
                              >;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                              state: optional<
                                  Enum<
                                      {
                                          INVALID: number;
                                          SPACE_ACTIVE: number;
                                          SPACE_CLOSED: number;
                                          SPACE_CONTROL_ONLY: number;
                                          SPACE_DELETED: number;
                                          SPACE_ERROR: number;
                                          SPACE_INACTIVE: number;
                                          SPACE_INITIALIZING: number;
                                          SPACE_READY: number;
                                          SPACE_REQUIRES_MIGRATION: number;
                                      },
                                  >,
                              >;
                          },
                      >,
                      Void,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.writeCredentials",
                      Struct<
                          {
                              credentials: optional<
                                  mutable<$Array<Codec<(...), (...), (...), (...)>>>,
                              >;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Void,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >,
                  Handlers,
              >,
      >

    • Implement a single handler from the group.

      Type Parameters

      • const Tag extends
            | "SpacesService.admitContact"
            | "SpacesService.createEpoch"
            | "SpacesService.createSpace"
            | "SpacesService.exportSpace"
            | "SpacesService.importSpace"
            | "SpacesService.joinBySpaceKey"
            | "SpacesService.postMessage"
            | "SpacesService.queryCredentials"
            | "SpacesService.querySpaces"
            | "SpacesService.subscribeMessages"
            | "SpacesService.updateMemberRole"
            | "SpacesService.updateSpace"
            | "SpacesService.writeCredentials"
      • Handler extends never
      • EX = never
      • RX = never

      Parameters

      Returns Layer<
          Handler<Tag>,
          EX,

              | Exclude<RX, Scope>
              | HandlerServices<
                  | Rpc<
                      "SpacesService.admitContact",
                      Struct<
                          {
                              contact: Codec<Contact, Uint8Array<ArrayBufferLike>, never, never>;
                              role: Enum<
                                  {
                                      ADMIN: number;
                                      EDITOR: number;
                                      INVALID: number;
                                      OWNER: number;
                                      READER: number;
                                      REMOVED: number;
                                  },
                              >;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Void,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.createEpoch",
                      Struct<
                          {
                              automergeRootUrl: optional<String>;
                              migration: optional<
                                  Enum<
                                      {
                                          FRAGMENT_AUTOMERGE_ROOT: number;
                                          INIT_AUTOMERGE: number;
                                          MIGRATE_REFERENCES_TO_DXN: number;
                                          NONE: number;
                                          PRUNE_AUTOMERGE_ROOT_HISTORY: number;
                                          REPLACE_AUTOMERGE_ROOT: number;
                                      },
                                  >,
                              >;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Codec<CreateEpochResponse, Uint8Array<ArrayBufferLike>, never, never>,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.createSpace",
                      Struct<
                          {
                              membershipPolicy: Enum<{ INVITE: number; LOCKED: number }>;
                              tags: optional<mutable<$Array<String>>>;
                          },
                      >,
                      Codec<Space, Uint8Array<ArrayBufferLike>, never, never>,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.exportSpace",
                      Struct<
                          {
                              format: optional<Enum<{ BINARY: number; JSON: number }>>;
                              spaceId: String;
                          },
                      >,
                      Struct<
                          {
                              archive: Struct<
                                  {
                                      contents: Uint8Array;
                                      filename: String;
                                      format: optional<Enum<(...)>>;
                                  },
                              >;
                          },
                      >,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.importSpace",
                      Struct<
                          {
                              archive: Struct<
                                  {
                                      contents: Uint8Array;
                                      filename: String;
                                      format: optional<Enum<(...)>>;
                                  },
                              >;
                              tags: optional<mutable<$Array<String>>>;
                          },
                      >,
                      Struct<{ newSpaceId: String }>,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.joinBySpaceKey",
                      Struct<
                          {
                              spaceKey: Codec<
                                  PublicKey,
                                  Uint8Array<ArrayBufferLike>,
                                  never,
                                  never,
                              >;
                          },
                      >,
                      Codec<JoinSpaceResponse, Uint8Array<ArrayBufferLike>, never, never>,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.postMessage",
                      Struct<
                          {
                              channel: String;
                              message: Codec<Any, Uint8Array<ArrayBufferLike>, never, never>;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Void,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.queryCredentials",
                      Struct<
                          {
                              noTail: optional<Boolean>;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Stream<
                          Codec<Credential, Uint8Array<ArrayBufferLike>, never, never>,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      >,
                      Never,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.querySpaces",
                      Void,
                      Stream<
                          Codec<
                              QuerySpacesResponse,
                              Uint8Array<ArrayBufferLike>,
                              never,
                              never,
                          >,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      >,
                      Never,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.subscribeMessages",
                      Struct<
                          {
                              channel: String;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Stream<
                          Codec<GossipMessage, Uint8Array<ArrayBufferLike>, never, never>,
                          Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      >,
                      Never,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.updateMemberRole",
                      Struct<
                          {
                              memberKey: Codec<
                                  PublicKey,
                                  Uint8Array<ArrayBufferLike>,
                                  never,
                                  never,
                              >;
                              newRole: Enum<
                                  {
                                      ADMIN: number;
                                      EDITOR: number;
                                      INVALID: number;
                                      OWNER: number;
                                      READER: number;
                                      REMOVED: number;
                                  },
                              >;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Void,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.updateSpace",
                      Struct<
                          {
                              edgeReplication: optional<
                                  Enum<{ DISABLED: number; ENABLED: number }>,
                              >;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                              state: optional<
                                  Enum<
                                      {
                                          INVALID: number;
                                          SPACE_ACTIVE: number;
                                          SPACE_CLOSED: number;
                                          SPACE_CONTROL_ONLY: number;
                                          SPACE_DELETED: number;
                                          SPACE_ERROR: number;
                                          SPACE_INACTIVE: number;
                                          SPACE_INITIALIZING: number;
                                          SPACE_READY: number;
                                          SPACE_REQUIRES_MIGRATION: number;
                                      },
                                  >,
                              >;
                          },
                      >,
                      Void,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >
                  | Rpc<
                      "SpacesService.writeCredentials",
                      Struct<
                          {
                              credentials: optional<
                                  mutable<$Array<Codec<(...), (...), (...), (...)>>>,
                              >;
                              spaceKey: Codec<PublicKey, Uint8Array<ArrayBufferLike>, never, never>;
                          },
                      >,
                      Void,
                      Codec<Error, Uint8Array<ArrayBufferLike>, never, never>,
                      never,
                      never,
                  >,
                  Tag,
                  Handler,
              >,
      >

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Methods