@voltro/plugin-chat 0.0.0-stage → 0.87.0

package/dist/index.d.ts

@@ -0,0 +1,623 @@
+import { ColumnBuilder } from '@voltro/database';
+import { DataStore } from '@voltro/database';
+import { Effect } from 'effect';
+import { EventClientPolicy } from '@voltro/protocol';
+import { FieldDefinitions } from '@voltro/database';
+import { PluginPrivacyTarget } from '@voltro/protocol';
+import { RateLimitStore } from '@voltro/plugin-ratelimit';
+import { RedisStoreOptions } from '@voltro/plugin-ratelimit';
+import { Schema } from 'effect';
+import { Scope } from 'effect/Scope';
+import { Subject } from '@voltro/protocol';
+import { Table } from '@voltro/database';
+import { VoltroPlugin } from '@voltro/protocol';
+import { YieldableError } from 'effect/Cause';
+
+/** Server integrations supply verified membership and transcripts, never browser rows. */
+declare interface ArchiveMatchInput {
+    readonly tenantId: string;
+    readonly matchId: string;
+    readonly name: string;
+    readonly members: CreateChatChannelInput['members'];
+    readonly messages: ReadonlyArray<{
+        readonly id: string;
+        readonly authorId: string;
+        readonly body: string;
+        readonly at: number;
+    }>;
+    readonly retentionMs?: number | null;
+}
+
+declare const CHANNEL_KINDS: readonly ["global", "lobby", "party", "guild", "match", "dm", "custom"];
+
+declare const channelChatRetention: (channel: ChatChannel) => number | null;
+
+/** Message versions are SQL INT columns; edits stop below this and redaction saturates at it. */
+export declare const CHAT_MAX_MESSAGE_VERSION = 2147483647;
+
+/** Upper bound of media rows one sweep step reads; storage deletes happen outside SQL. */
+export declare const CHAT_MEDIA_SWEEP_BATCH_SIZE = 50;
+
+export declare const CHAT_RETENTION_BATCH_SIZE = 200;
+
+export declare const CHAT_RETENTION_RUN_BATCHES = 10;
+
+/** Durable identity admission and redacted erasure tombstone. Never deleted by history retention. */
+export declare const chatAdmissionsTable: Table<"_voltro_chat_admissions", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly subjectId: ColumnBuilder<string | null, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly erased: ColumnBuilder<boolean, "boolean", boolean>;
+}>, true, never>;
+
+export declare type ChatAuthorProjection = typeof ChatAuthorProjectionSchema.Type;
+
+/** Roster-only identity; displayName already includes the Players tag. */
+declare const ChatAuthorProjectionSchema: Schema.Struct<{
+    readonly subjectId: Schema.String;
+    readonly displayName: Schema.String;
+    readonly avatar: Schema.NullOr<Schema.String>;
+}>;
+
+export declare interface ChatAuthorsInput {
+    readonly channelId: string;
+    readonly subjectIds: ReadonlyArray<string>;
+}
+
+export declare type ChatChannel = typeof ChatChannelSchema.Type;
+
+declare const ChatChannelSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["global", "lobby", "party", "guild", "match", "dm", "custom"]>;
+    readonly refId: Schema.String;
+    readonly name: Schema.String;
+    readonly slowModeMs: Schema.Number;
+    readonly retentionMs: Schema.NullOr<Schema.Number>;
+    readonly maxMembers: Schema.Number;
+    readonly frozen: Schema.Boolean;
+    readonly createdAt: Schema.Number;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+
+export declare const chatChannelsTable: Table<"_voltro_chat_channels", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly kind: ColumnBuilder<"custom" | "match" | "global" | "lobby" | "party" | "guild" | "dm", "text", boolean>;
+    readonly refId: ColumnBuilder<string, "text", boolean>;
+    readonly name: ColumnBuilder<string, "text", boolean>;
+    readonly slowModeMs: ColumnBuilder<number, "integer", boolean>;
+    readonly retentionMs: ColumnBuilder<number | null, "integer", boolean>;
+    readonly maxMembers: ColumnBuilder<number, "integer", boolean>;
+    readonly frozen: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly creationKey: ColumnBuilder<string, "text", boolean>;
+    readonly metadata: ColumnBuilder<unknown, "json", boolean>;
+}>, true, never>;
+
+export declare class ChatError extends ChatError_base {
+}
+
+declare const ChatError_base: Schema.Class<ChatError, Schema.TaggedStruct<"ChatError", {
+    readonly code: Schema.Literals<readonly ["identity_required", "invalid_input", "not_found", "forbidden", "blocked", "sanctioned", "muted", "slow_mode", "rate_limited", "content_rejected", "conflict", "frozen", "member_limit", "unavailable", "export_limit"]>;
+}>, YieldableError>;
+
+declare interface ChatEvidenceSnapshot {
+    readonly id: string;
+    readonly channelId: string;
+    readonly messageId: string;
+    readonly messageVersion: number;
+    readonly kind: string;
+    readonly authorId: string | null;
+    readonly body: string | null;
+    readonly originalBody: string | null;
+    readonly createdAt: number;
+    readonly editedAt: number | null;
+    readonly deletedAt: number | null;
+    readonly capturedAt: number;
+    readonly expiresAt: number;
+    readonly erasedAt: number | null;
+}
+
+/** Private immutable content captures. Cases contain references, never copies of this text. */
+export declare const chatEvidenceTable: Table<"_voltro_chat_evidence", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly channelId: ColumnBuilder<string, "text", boolean>;
+    readonly messageId: ColumnBuilder<string, "text", boolean>;
+    readonly messageVersion: ColumnBuilder<number, "integer", boolean>;
+    readonly kind: ColumnBuilder<string, "text", boolean>;
+    readonly authorId: ColumnBuilder<string | null, "text", boolean>;
+    readonly body: ColumnBuilder<string, "text", boolean>;
+    readonly originalBody: ColumnBuilder<string, "text", boolean>;
+    readonly messageCreatedAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly messageEditedAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+    readonly messageDeletedAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+    readonly capturedAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly expiresAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly erasedAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+}>, true, never>;
+
+export declare type ChatMediaAttachment = typeof ChatMediaAttachmentSchema.Type;
+
+/** Server-verified attachment facts copied into `payload.media`; bytes stay in plugin-storage. */
+declare const ChatMediaAttachmentSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly contentType: Schema.String;
+    readonly size: Schema.Number;
+    readonly width: Schema.NullOr<Schema.Number>;
+    readonly height: Schema.NullOr<Schema.Number>;
+}>;
+
+export declare interface ChatMediaInput {
+    readonly subject: Subject;
+    /** Facts read from plugin-storage for a ref the sender owns in this tenant. */
+    readonly ref: {
+        readonly id: string;
+        readonly contentType: string;
+        readonly size: number;
+        readonly width: number | null;
+        readonly height: number | null;
+    };
+    readonly contentTypes: ReadonlyArray<string>;
+    readonly maxBytes: number;
+}
+
+declare interface ChatMediaSweep {
+    readonly removed: number;
+    readonly failed: number;
+    readonly remaining: boolean;
+}
+
+/** One row per media message. `deleting` rows wait for the bounded storage sweep; the blob is never deleted inside SQL. */
+export declare const chatMediaTable: Table<"_voltro_chat_media", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly channelId: ColumnBuilder<string, "text", boolean>;
+    readonly messageId: ColumnBuilder<string, "text", boolean>;
+    readonly storageId: ColumnBuilder<string, "text", boolean>;
+    readonly ownerId: ColumnBuilder<string | null, "text", boolean>;
+    readonly state: ColumnBuilder<"active" | "deleting", "text", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>;
+
+export declare type ChatMediaUrl = typeof ChatMediaUrlSchema.Type;
+
+declare const ChatMediaUrlSchema: Schema.Struct<{
+    readonly url: Schema.String;
+    readonly expiresAt: Schema.Number;
+}>;
+
+export declare interface ChatMediaVerdict {
+    readonly allowed: boolean;
+    readonly flagged: boolean;
+}
+
+export declare type ChatMember = typeof ChatMemberSchema.Type;
+
+declare const ChatMemberSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly channelId: Schema.String;
+    readonly subjectId: Schema.String;
+    readonly role: Schema.Literals<readonly ["member", "mod", "owner"]>;
+    readonly mutedUntil: Schema.NullOr<Schema.Number>;
+    readonly lastReadAt: Schema.Number;
+    readonly lastReadId: Schema.NullOr<Schema.String>;
+    readonly notify: Schema.Boolean;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+
+export declare const chatMembersTable: Table<"_voltro_chat_members", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly channelId: ColumnBuilder<string, "text", boolean>;
+    readonly subjectId: ColumnBuilder<string, "text", boolean>;
+    readonly role: ColumnBuilder<"member" | "owner" | "mod", "text", boolean>;
+    readonly mutedUntil: ColumnBuilder<Date | null, "timestamp", boolean>;
+    readonly lastReadAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly lastReadId: ColumnBuilder<string | null, "text", boolean>;
+    readonly lastSentAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+    readonly notify: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly metadata: ColumnBuilder<unknown, "json", boolean>;
+}>, true, never>;
+
+export declare type ChatMentionCandidates = typeof ChatMentionCandidatesSchema.Type;
+
+export declare interface ChatMentionCandidatesInput {
+    readonly channelId: string;
+    readonly after?: string;
+}
+
+declare const ChatMentionCandidatesSchema: Schema.Struct<{
+    readonly authors: Schema.$Array<Schema.Struct<{
+        readonly subjectId: Schema.String;
+        readonly displayName: Schema.String;
+        readonly avatar: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly after: Schema.NullOr<Schema.String>;
+}>;
+
+declare interface ChatMentionDeliveryInput {
+    readonly tenantId: string;
+    readonly channelId: string;
+    readonly messageId: string;
+    readonly recipientId: string;
+}
+
+declare interface ChatMentionInput {
+    readonly body: string;
+    readonly subject: Subject;
+    readonly maxMentions?: number;
+}
+
+export declare type ChatMessage = typeof ChatMessageSchema.Type;
+
+export declare type ChatMessagePage = typeof ChatMessagePageSchema.Type;
+
+declare const ChatMessagePageSchema: Schema.Struct<{
+    readonly messages: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly channelId: Schema.String;
+        readonly authorId: Schema.NullOr<Schema.String>;
+        readonly kind: Schema.Literals<readonly ["text", "emote", "system", "media"]>;
+        readonly body: Schema.String;
+        readonly payload: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly replyToId: Schema.NullOr<Schema.String>;
+        readonly editedAt: Schema.NullOr<Schema.Number>;
+        readonly deletedAt: Schema.NullOr<Schema.Number>;
+        readonly flagged: Schema.Boolean;
+        readonly createdAt: Schema.Number;
+        readonly version: Schema.Number;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+    }>>;
+    readonly before: Schema.NullOr<Schema.Struct<{
+        readonly at: Schema.Number;
+        readonly id: Schema.String;
+    }>>;
+}>;
+
+declare const ChatMessageSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly channelId: Schema.String;
+    readonly authorId: Schema.NullOr<Schema.String>;
+    readonly kind: Schema.Literals<readonly ["text", "emote", "system", "media"]>;
+    readonly body: Schema.String;
+    readonly payload: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly replyToId: Schema.NullOr<Schema.String>;
+    readonly editedAt: Schema.NullOr<Schema.Number>;
+    readonly deletedAt: Schema.NullOr<Schema.Number>;
+    readonly flagged: Schema.Boolean;
+    readonly createdAt: Schema.Number;
+    readonly version: Schema.Number;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+
+export declare const chatMessagesTable: Table<"_voltro_chat_messages", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string, "text", boolean>;
+    readonly channelId: ColumnBuilder<string, "text", boolean>;
+    readonly authorId: ColumnBuilder<string | null, "text", boolean>;
+    readonly requestKey: ColumnBuilder<string, "text", boolean>;
+    readonly kind: ColumnBuilder<"text" | "system" | "emote" | "media", "text", boolean>;
+    readonly body: ColumnBuilder<string, "text", boolean>;
+    readonly originalBody: ColumnBuilder<string, "text", boolean>;
+    readonly payload: ColumnBuilder<unknown, "json", boolean>;
+    readonly replyToId: ColumnBuilder<string | null, "text", boolean>;
+    readonly editedAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+    readonly deletedAt: ColumnBuilder<Date | null, "timestamp", boolean>;
+    readonly flagged: ColumnBuilder<boolean, "boolean", boolean>;
+    readonly createdAt: ColumnBuilder<Date, "timestamp", boolean>;
+    readonly version: ColumnBuilder<number, "integer", boolean>;
+    readonly metadata: ColumnBuilder<unknown, "json", boolean>;
+}>, true, never>;
+
+export declare interface ChatModerationInput {
+    readonly body: string;
+    readonly denyWords: ReadonlyArray<string>;
+    readonly action: 'block' | 'flag';
+}
+
+export declare interface ChatModerationResult {
+    readonly body: string;
+    readonly flagged: boolean;
+    readonly allowed: boolean;
+}
+
+export declare interface ChatOptions {
+    readonly maxBodyLength?: number;
+    readonly pageSize?: number;
+    readonly maxMembers?: number;
+    readonly maxChannelsPerSubject?: number;
+    readonly retentionMs?: number | null;
+    readonly evidenceRetentionMs?: number;
+    readonly perChannelRate?: number;
+    readonly globalRate?: number;
+    readonly maxMentions?: number;
+    readonly maxExportRows?: number;
+    readonly denyWords?: ReadonlyArray<string>;
+    readonly moderationAction?: 'block' | 'flag';
+    readonly strategies?: Partial<ChatStrategies>;
+    readonly mediaContentTypes?: ReadonlyArray<string>;
+    readonly maxMediaBytes?: number;
+    readonly mediaUrlTtlSec?: number;
+    readonly rateLimit?: RedisStoreOptions;
+    readonly now?: () => number;
+}
+
+export declare type ChatOriginal = typeof ChatOriginalSchema.Type;
+
+declare const ChatOriginalSchema: Schema.Struct<{
+    readonly message: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly channelId: Schema.String;
+        readonly authorId: Schema.NullOr<Schema.String>;
+        readonly kind: Schema.Literals<readonly ["text", "emote", "system", "media"]>;
+        readonly body: Schema.String;
+        readonly payload: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly replyToId: Schema.NullOr<Schema.String>;
+        readonly editedAt: Schema.NullOr<Schema.Number>;
+        readonly deletedAt: Schema.NullOr<Schema.Number>;
+        readonly flagged: Schema.Boolean;
+        readonly createdAt: Schema.Number;
+        readonly version: Schema.Number;
+        readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+    }>;
+    readonly originalBody: Schema.String;
+}>;
+
+export declare const chatPlugin: (input?: ChatOptions) => VoltroPlugin;
+
+export declare interface ChatRateInput {
+    readonly channel: ChatChannel;
+    readonly perChannel: number;
+    readonly global: number;
+}
+
+declare interface ChatReportContextEvidence {
+    readonly kind: 'chat.context';
+    readonly channelId: string;
+    readonly anchorMessageId: string;
+    readonly observedAt: number;
+    readonly messages: ReadonlyArray<{
+        readonly evidenceId: string | null;
+        readonly messageId: string;
+        readonly version: number;
+        readonly createdAt: number;
+        readonly deletedAt: number | null;
+    }>;
+}
+
+declare interface ChatReportContextInput {
+    readonly channelId: string;
+    readonly messageId: string;
+    readonly targetId: string;
+}
+
+declare interface ChatRetentionBatch {
+    readonly deleted: number;
+    readonly evidenceDeleted: number;
+    readonly channelId: string | null;
+    readonly remainingInChannel: boolean;
+    readonly evidenceRemainingInChannel: boolean;
+    readonly cycleComplete: boolean;
+}
+
+/** App-owned sweep progress, not a player's profile/history record. */
+export declare const chatRetentionTable: Table<"_voltro_chat_retention", FieldDefinitions<{
+    readonly id: ColumnBuilder<string, "id", boolean>;
+    readonly tenantId: ColumnBuilder<string | null, "text", boolean>;
+    readonly afterChannelId: ColumnBuilder<string | null, "text", boolean>;
+    readonly admission: ColumnBuilder<number, "integer", boolean>;
+    readonly updatedAt: ColumnBuilder<Date, "timestamp", boolean>;
+}>, true, never>;
+
+export declare interface ChatService {
+    readonly mentionCandidates: (subject: Subject, input: ChatMentionCandidatesInput) => Effect.Effect<ChatMentionCandidates, ChatError>;
+    readonly authors: (subject: Subject, input: ChatAuthorsInput) => Effect.Effect<ReadonlyArray<ChatAuthorProjection>, ChatError>;
+    readonly prepareTyping: (subject: Subject, input: SetChatTypingInput) => Effect.Effect<ChatTyping, ChatError>;
+    readonly dm: (subject: Subject, otherId: string) => Effect.Effect<ChatChannel, ChatError>;
+    readonly send: (subject: Subject, input: SendChatInput) => Effect.Effect<ChatMessage, ChatError>;
+    readonly edit: (subject: Subject, input: EditChatInput) => Effect.Effect<ChatMessage, ChatError>;
+    readonly remove: (subject: Subject, input: DeleteChatInput) => Effect.Effect<ChatMessage, ChatError>;
+    readonly messages: (subject: Subject, input: {
+        readonly channelId: string;
+        readonly before?: {
+            readonly at: number;
+            readonly id: string;
+        } | undefined;
+    }) => Effect.Effect<ChatMessagePage, ChatError>;
+    readonly channel: (subject: Subject, channelId: string) => Effect.Effect<ChatChannel, ChatError>;
+    readonly membership: (subject: Subject, channelId: string) => Effect.Effect<ChatMember, ChatError>;
+    readonly channels: (subject: Subject) => Effect.Effect<ReadonlyArray<ChatChannel>, ChatError>;
+    readonly unread: (subject: Subject) => Effect.Effect<ReadonlyArray<ChatUnread>, ChatError>;
+    readonly original: (subject: Subject, messageId: string) => Effect.Effect<ChatOriginal, ChatError>;
+    /** Short-lived storage URL for one retained media message the caller may read. */
+    readonly mediaUrl: (subject: Subject, messageId: string) => Effect.Effect<ChatMediaUrl, ChatError>;
+    readonly markRead: (subject: Subject, channelId: string, messageId: string) => Effect.Effect<ChatMember, ChatError>;
+    readonly moderateMember: (subject: Subject, input: {
+        readonly channelId: string;
+        readonly subjectId: string;
+        readonly mutedUntil: number | null;
+    }) => Effect.Effect<ChatMember, ChatError>;
+    readonly configure: (subject: Subject, input: {
+        readonly channelId: string;
+        readonly slowModeMs?: number | undefined;
+        readonly frozen?: boolean | undefined;
+    }) => Effect.Effect<ChatChannel, ChatError>;
+    /** Self-service membership for open `global` channels only; other kinds stay server-administered. */
+    readonly join: (subject: Subject, channelId: string) => Effect.Effect<ChatMember, ChatError>;
+    readonly leave: (subject: Subject, channelId: string) => Effect.Effect<void, ChatError>;
+    readonly transferOwnership: (subject: Subject, channelId: string, targetId: string) => Effect.Effect<void, ChatError>;
+}
+
+export declare interface ChatStrategies {
+    readonly moderate: typeof keywordChatModeration;
+    readonly rateLimit: typeof fixedChatRateBudgets;
+    readonly mentionResolver: typeof playerChatMentions;
+    readonly retention: typeof channelChatRetention;
+    readonly moderateMedia: typeof typedChatMedia;
+}
+
+export declare const chatSystemContract: {
+    readonly slots: {
+        readonly moderate: {
+            readonly defaultExport: "keywordChatModeration";
+            readonly fixtureExport: "chatModerationFixture";
+        };
+        readonly rateLimit: {
+            readonly defaultExport: "fixedChatRateBudgets";
+            readonly fixtureExport: "chatRateLimitFixture";
+        };
+        readonly mentionResolver: {
+            readonly defaultExport: "playerChatMentions";
+            readonly fixtureExport: "chatMentionResolverFixture";
+        };
+        readonly retention: {
+            readonly defaultExport: "channelChatRetention";
+            readonly fixtureExport: "chatRetentionFixture";
+        };
+        readonly moderateMedia: {
+            readonly defaultExport: "typedChatMedia";
+            readonly fixtureExport: "chatMediaModerationFixture";
+        };
+    };
+    readonly ports: {};
+    readonly events: readonly ["chat.messageChanged", "chat.mentioned", "chat.typing"];
+};
+
+export declare type ChatTyping = typeof ChatTypingSchema.Type;
+
+declare const ChatTypingSchema: Schema.Struct<{
+    readonly subjectId: Schema.NonEmptyString;
+    readonly active: Schema.Boolean;
+    readonly expiresAt: Schema.Number;
+}>;
+
+export declare type ChatUnread = typeof ChatUnreadSchema.Type;
+
+declare const ChatUnreadSchema: Schema.Struct<{
+    readonly channelId: Schema.String;
+    readonly count: Schema.Number;
+    readonly truncated: Schema.Boolean;
+}>;
+
+export declare interface CreateChatChannelInput {
+    readonly tenantId: string;
+    readonly kind: typeof CHANNEL_KINDS[number];
+    readonly refId: string;
+    readonly name: string;
+    readonly members: ReadonlyArray<{
+        readonly subjectId: string;
+        readonly role: ChatMember['role'];
+    }>;
+    readonly slowModeMs?: number;
+    readonly retentionMs?: number | null;
+    readonly maxMembers?: number;
+}
+
+export declare const dataStoreChat: (store: DataStore, options: ResolvedChatOptions, limiter: RateLimitStore) => {
+    service: ChatService;
+    typingPolicy: {
+        id: string;
+        admit: (value: Parameters< EventClientPolicy["admit"]>[0]) => Effect.Effect<boolean, never, never>;
+        deliver: (value: Parameters< EventClientPolicy["deliver"]>[0]) => Effect.Effect<"allow" | "drop" | "deny", never, never>;
+        monitor: (value: Parameters< EventClientPolicy["admit"]>[0]) => Effect.Effect<Effect.Effect<void, never, never>, ChatError, Scope>;
+    };
+    disposeTyping: () => void;
+    readReportEvidence: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly evidenceIds: ReadonlyArray<string>;
+    }) => Effect.Effect<ReadonlyArray< ChatEvidenceSnapshot>, ChatError>;
+    collectReportContext: (subject: Subject, input: ChatReportContextInput) => Effect.Effect< ChatReportContextEvidence, ChatError>;
+    prune: (subject: Subject) => Effect.Effect< ChatRetentionBatch, ChatError>;
+    sweepMedia: (subject: Subject) => Effect.Effect< ChatMediaSweep, ChatError>;
+    canNotifyMention: (subject: Subject, input: ChatMentionDeliveryInput) => Effect.Effect<boolean, ChatError>;
+    createChannel: (identity: Subject, intention: CreateChatChannelInput) => Effect.Effect<ChatChannel, ChatError>;
+    addMember: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly channelId: string;
+        readonly subjectId: string;
+        readonly role: "member" | "mod";
+    }) => Effect.Effect<ChatMember, ChatError>;
+    removeMember: (subject: Subject, input: {
+        readonly tenantId: string;
+        readonly channelId: string;
+        readonly subjectId: string;
+    }) => Effect.Effect<void, ChatError>;
+    archiveMatch: (subject: Subject, input: ArchiveMatchInput) => Effect.Effect<ChatChannel, ChatError>;
+    exportSubject: (target: PluginPrivacyTarget) => Effect.Effect<unknown, ChatError, never>;
+    eraseSubject: (input: PluginPrivacyTarget) => Effect.Effect<void, ChatError, never>;
+};
+
+export declare const defaultChatStrategies: ChatStrategies;
+
+export declare interface DeleteChatInput {
+    readonly messageId: string;
+    readonly baseVersion: number;
+}
+
+export declare interface EditChatInput {
+    readonly messageId: string;
+    readonly baseVersion: number;
+    readonly body: string;
+}
+
+declare const fixedChatRateBudgets: (input: ChatRateInput) => {
+    readonly perChannel: number;
+    readonly global: number;
+};
+
+/** Composition over the existing moderation provider, not another classifier. */
+declare const keywordChatModeration: (input: ChatModerationInput) => Effect.Effect<ChatModerationResult, ChatError>;
+
+/** Exact Name#Tag claims from Players; Chat still admits every result against its channel. */
+declare const playerChatMentions: (input: ChatMentionInput) => Effect.Effect<ReadonlyArray<string>, ChatError>;
+
+export declare const resolveChatOptions: (options?: ChatOptions) => Readonly<{
+    maxBodyLength: number;
+    pageSize: number;
+    maxMembers: number;
+    evidenceRetentionMs: number;
+    maxChannelsPerSubject: number;
+    retentionMs: number | null;
+    perChannelRate: number;
+    globalRate: number;
+    maxMentions: number;
+    maxExportRows: number;
+    denyWords: readonly string[];
+    moderationAction: "flag" | "block";
+    mediaContentTypes: readonly string[];
+    maxMediaBytes: number;
+    mediaUrlTtlSec: number;
+    strategies: Readonly<{
+        moderate: typeof keywordChatModeration;
+        rateLimit: typeof fixedChatRateBudgets;
+        mentionResolver: typeof playerChatMentions;
+        retention: typeof channelChatRetention;
+        moderateMedia: typeof typedChatMedia;
+    }>;
+    rateLimit: RedisStoreOptions | undefined;
+    now: () => number;
+}>;
+
+declare type ResolvedChatOptions = ReturnType<typeof resolveChatOptions>;
+
+/** `mediaId` names a `_voltro_storage_refs` row the sender uploaded; the body is then an optional caption. */
+export declare interface SendChatInput {
+    readonly channelId: string;
+    readonly requestId: string;
+    readonly body: string;
+    readonly replyToId?: string | undefined;
+    readonly mediaId?: string | undefined;
+}
+
+export declare interface SetChatTypingInput {
+    readonly channelId: string;
+    readonly active: boolean;
+}
+
+/** Declared type and size bounds only. Image classification is an integration: replace this slot to call a provider. */
+declare const typedChatMedia: (input: ChatMediaInput) => Effect.Effect<ChatMediaVerdict, ChatError>;
+
+export { }