Variable communityConst

Type Declaration

• Readonlyattachment: {
      issue: (
          input: {
              content: Uint8Array<ArrayBuffer>;
              idempotencyKey: string;
              mediaType:
                  | "image/png"
                  | "image/jpeg"
                  | "image/webp"
                  | "text/plain"
                  | "application/pdf"
                  | "image/gif"
                  | "text/csv"
                  | "text/markdown";
              name: string;
          },
      ) => Promise<
          {
              bytes: number;
              mediaType: | "image/png"
              | "image/jpeg"
              | "image/webp"
              | "text/plain"
              | "application/pdf"
              | "image/gif"
              | "text/csv"
              | "text/markdown";
              name: string;
              receiptId: string;
          },
      >;
  }

• Readonlyissue: {
      affect: (
          input: { idempotencyKey: string; issueReportId: string },
      ) => Promise<CommunityEntityActionResult>;
      create: (
          input: {
              actualBehavior: string;
              classification: "bug" | "feature" | "question";
              expectedBehavior: string;
              idempotencyKey: string;
              reproductionSteps: string[];
              title: string;
          },
      ) => Promise<CommunityEntityActionResult>;
  }

• Readonlymember: {
      claim: (
          input: {
              bio?: string;
              displayName: string;
              handle?: string;
              idempotencyKey: string;
          },
      ) => Promise<CommunityMemberClaimWireResult>;
      current: () => Promise<CommunityMemberCurrentWireResult>;
  }

• Readonlymessage: {
      create: (
          input: {
              attachmentReceiptId?: string;
              body: string;
              channelId?: string;
              channelRef?: string;
              idempotencyKey: string;
              mentionHandles?: string[];
              replyToMessageId?: string;
              replyToMessageRef?: string;
          },
      ) => Promise<CommunityMessageCreateResult>;
      delete: (
          input: { idempotencyKey: string; messageRef: string },
      ) => Promise<CommunityMessageDeleteResult>;
      edit: (
          input: { body: string; idempotencyKey: string; messageRef: string },
      ) => Promise<CommunityMessageEditResult>;
  }

• Readonlymoderation: {
      apply: (
          input: {
              action:
                  | { kind: "message-delete"; targetId: string }
                  | { kind: "channel-lock"; targetId: string }
                  | { kind: "channel-unlock"; targetId: string }
                  | { kind: "member-suspend"; targetHandle: string }
                  | { kind: "member-restore"; targetHandle: string };
              idempotencyKey: string;
              reason: string;
          },
      ) => Promise<CommunityModerationApplyResult>;
      audit: {
          list: (
              input?: {
                  actions?: (
                      | "message-delete"
                      | "channel-lock"
                      | "channel-unlock"
                      | "member-suspend"
                      | "member-restore"
                      | "settings-update"
                      | "channel-create"
                      | "channel-update"
                      | "channel-reorder"
                      | "channel-archive"
                      | "channel-restore"
                      | "moderator-promote"
                      | "moderator-demote"
                      | "issue-redact"
                  )[];
                  cursor?: string;
                  limit?: number;
              },
          ) => Promise<CommunityModerationAuditResult>;
      };
      memberStatus: {
          set: (
              input: {
                  idempotencyKey: string;
                  reason: string;
                  status: "active" | "suspended";
                  target: string;
              },
          ) => Promise<CommunityMemberOperatorActionResult>;
      };
  }

• Readonlyoperator: {
      roster: {
          list: (
              input?: { cursor?: string; limit?: number },
          ) => Promise<CommunityOperatorRosterResult>;
      };
  }

• Readonlyowner: {
      channel: {
          create: (
              input: {
                  description?: string;
                  idempotencyKey: string;
                  mode?: "issues" | "chat" | "announcements" | "topics";
                  name: string;
                  postingPolicy?: "members" | "moderators" | "read-only";
                  ratePolicy?: {
                      burstLimit?: number;
                      burstWindowSeconds?: number;
                      minimumIntervalSeconds?: number;
                  };
                  slug: string;
                  visibility: "public"
                  | "members"
                  | "moderators";
              },
          ) => Promise<CommunityChannelActionResult>;
          list: (
              input?: { cursor?: string; limit?: number },
          ) => Promise<CommunityChannelListResult>;
          reorder: (
              input: { idempotencyKey: string; targets: string[] },
          ) => Promise<CommunityChannelListResult>;
          state: (
              input: {
                  idempotencyKey: string;
                  state: "archived" | "locked" | "unlocked" | "restored";
                  target: string;
              },
          ) => Promise<CommunityChannelActionResult>;
          update: (
              input: {
                  idempotencyKey: string;
                  patch: {
                      description?: string;
                      mode?: "issues" | "chat" | "announcements" | "topics";
                      name?: string;
                      postingPolicy?: "members" | "moderators" | "read-only";
                      ratePolicy?: {
                          burstLimit?: number;
                          burstWindowSeconds?: number;
                          minimumIntervalSeconds?: number;
                      };
                      visibility?: "public"
                      | "members"
                      | "moderators";
                  };
                  target: string;
              },
          ) => Promise<CommunityChannelActionResult>;
      };
      moderator: {
          set: (
              input: {
                  idempotencyKey: string;
                  reason: string;
                  role: "member" | "moderator";
                  target: string;
              },
          ) => Promise<CommunityMemberOperatorActionResult>;
      };
      settings: {
          update: (
              input: {
                  idempotencyKey: string;
                  patch: {
                      defaultChannelTarget?: string;
                      description?: string;
                      name?: string;
                      onboarding?: {
                          rules?: string[];
                          rulesVersion?: string;
                          suggestedChannelTargets?: string[];
                          welcome?: string;
                      };
                      visibility?: "public"
                      | "private";
                  };
              },
          ) => Promise<CommunitySettingsActionResult>;
      };
  }

• Readonlyprojection: {
      read: () => Promise<
          {
              projection: {
                  channels: {
                      archivedAt?: string;
                      channelRef: string;
                      createdAt: string;
                      description?: string;
                      locked: boolean;
                      mode: "issues"
                      | "chat"
                      | "announcements"
                      | "topics";
                      name: string;
                      position: number;
                      postingPolicy: "members" | "moderators" | "read-only";
                      ratePolicy?: {
                          burstLimit?: (...) | (...);
                          burstWindowSeconds?: (...) | (...);
                          minimumIntervalSeconds?: (...) | (...);
                      };
                      slug: string;
                      version: number;
                      visibility: "public"
                      | "members"
                      | "moderators";
                  }[];
                  messages: {
                      attachmentReceipt?: {
                          bytes: number;
                          mediaType: | (...)
                          | (...)
                          | (...)
                          | (...)
                          | (...)
                          | (...)
                          | (...)
                          | (...);
                          name: string;
                          receiptId: string;
                      };
                      author: { displayName: string; handle: string; profileRef: string };
                      body: string;
                      channelRef: string;
                      createdAt: string;
                      editedAt?: string;
                      mentions: { displayName: string; handle: string; profileRef: string }[];
                      messageRef: string;
                      parent?: {
                          authorDisplayName: string;
                          body: string;
                          createdAt: string;
                          messageRef: string;
                      };
                      reactions: { count: number; emoji: string; reactedByViewer: boolean }[];
                      version: number;
                  }[];
                  operator?: {
                      audit: {
                          action: string;
                          actorLabel: string;
                          createdAt: string;
                          reason: string;
                          target: (...)
                          | (...);
                          targetLabel: string;
                      }[];
                      channels: {
                          archivedAt?: (...)
                          | (...);
                          createdAt: string;
                          description?: (...) | (...);
                          locked: boolean;
                          mode: (...) | (...) | (...) | (...);
                          name: string;
                          position: number;
                          postingPolicy: (...) | (...) | (...);
                          ratePolicy?: (...) | (...);
                          slug: string;
                          target: string;
                          version: number;
                          visibility: (...) | (...) | (...);
                      }[];
                      roster: {
                          bio?: (...)
                          | (...);
                          displayName: string;
                          handle: string;
                          joinedAt: string;
                          role: (...) | (...);
                          status: (...) | (...) | (...);
                          target: string;
                          version: number;
                      }[];
                  };
              };
          },
      >;
      subscribe: (
          onChange: (
              delivery:
                  | {
                      eventCursor: number;
                      kind: "seed";
                      projection: {
                          channels: {
                              archivedAt?: string;
                              channelRef: string;
                              createdAt: string;
                              description?: string;
                              locked: boolean;
                              mode: "issues"
                              | "chat"
                              | "announcements"
                              | "topics";
                              name: string;
                              position: number;
                              postingPolicy: "members" | "moderators" | "read-only";
                              ratePolicy?: {
                                  burstLimit?: ...;
                                  burstWindowSeconds?: ...;
                                  minimumIntervalSeconds?: ...;
                              };
                              slug: string;
                              version: number;
                              visibility: "public"
                              | "members"
                              | "moderators";
                          }[];
                          messages: {
                              attachmentReceipt?: {
                                  bytes: ...;
                                  mediaType: ...;
                                  name: ...;
                                  receiptId: ...;
                              };
                              author: { displayName: string; handle: string; profileRef: string };
                              body: string;
                              channelRef: string;
                              createdAt: string;
                              editedAt?: string;
                              mentions: { displayName: ...; handle: ...; profileRef: ... }[];
                              messageRef: string;
                              parent?: {
                                  authorDisplayName: ...;
                                  body: ...;
                                  createdAt: ...;
                                  messageRef: ...;
                              };
                              reactions: { count: ...; emoji: ...; reactedByViewer: ... }[];
                              version: number;
                          }[];
                          operator?: {
                              audit: {
                                  action: ...;
                                  actorLabel: ...;
                                  createdAt: ...;
                                  reason: ...;
                                  target: ...;
                                  targetLabel: ...;
                              }[];
                              channels: {
                                  archivedAt?: ...;
                                  createdAt: ...;
                                  description?: ...;
                                  locked: ...;
                                  mode: ...;
                                  name: ...;
                                  position: ...;
                                  postingPolicy: ...;
                                  ratePolicy?: ...;
                                  slug: ...;
                                  target: ...;
                                  version: ...;
                                  visibility: ...;
                              }[];
                              roster: {
                                  bio?: ...;
                                  displayName: ...;
                                  handle: ...;
                                  joinedAt: ...;
                                  role: ...;
                                  status: ...;
                                  target: ...;
                                  version: ...;
                              }[];
                          };
                      };
                      recoveryCursor: string;
                  }
                  | {
                      eventCursor: number;
                      kind: "delta";
                      projection: {
                          channels: {
                              archivedAt?: string;
                              channelRef: string;
                              createdAt: string;
                              description?: string;
                              locked: boolean;
                              mode: "issues"
                              | "chat"
                              | "announcements"
                              | "topics";
                              name: string;
                              position: number;
                              postingPolicy: "members" | "moderators" | "read-only";
                              ratePolicy?: {
                                  burstLimit?: ...;
                                  burstWindowSeconds?: ...;
                                  minimumIntervalSeconds?: ...;
                              };
                              slug: string;
                              version: number;
                              visibility: "public"
                              | "members"
                              | "moderators";
                          }[];
                          messages: {
                              attachmentReceipt?: {
                                  bytes: ...;
                                  mediaType: ...;
                                  name: ...;
                                  receiptId: ...;
                              };
                              author: { displayName: string; handle: string; profileRef: string };
                              body: string;
                              channelRef: string;
                              createdAt: string;
                              editedAt?: string;
                              mentions: { displayName: ...; handle: ...; profileRef: ... }[];
                              messageRef: string;
                              parent?: {
                                  authorDisplayName: ...;
                                  body: ...;
                                  createdAt: ...;
                                  messageRef: ...;
                              };
                              reactions: { count: ...; emoji: ...; reactedByViewer: ... }[];
                              version: number;
                          }[];
                          operator?: {
                              audit: {
                                  action: ...;
                                  actorLabel: ...;
                                  createdAt: ...;
                                  reason: ...;
                                  target: ...;
                                  targetLabel: ...;
                              }[];
                              channels: {
                                  archivedAt?: ...;
                                  createdAt: ...;
                                  description?: ...;
                                  locked: ...;
                                  mode: ...;
                                  name: ...;
                                  position: ...;
                                  postingPolicy: ...;
                                  ratePolicy?: ...;
                                  slug: ...;
                                  target: ...;
                                  version: ...;
                                  visibility: ...;
                              }[];
                              roster: {
                                  bio?: ...;
                                  displayName: ...;
                                  handle: ...;
                                  joinedAt: ...;
                                  role: ...;
                                  status: ...;
                                  target: ...;
                                  version: ...;
                              }[];
                          };
                      };
                  }
                  | { kind: "reset"; reason: "recovery-gap"
                  | "authority-changed" },
          ) => void,
      ) => CommunityProjectionSubscription;
  }

• Readonlyreaction: {
      set: (
          input: {
              active: boolean;
              emoji: string;
              idempotencyKey: string;
              messageRef: string;
          },
      ) => Promise<CommunityReactionSetResult>;
  }

• Readonlysearch: (input: { limit: number; query: string }) => Promise<CommunitySearchResult>