import { MilkyClient, milky } from "@fraqjs/fraq";
import { AiService } from "@fraqjs/plugin-ai";
import { HonoService } from "@fraqjs/plugin-hono";
import { FraqDatabase, KyselyService } from "@fraqjs/plugin-kysely";
import { WebuiGatewayService } from "@fraqjs/plugin-webui-gateway";
import { Kysely } from "kysely";

//#region src/models/index.d.ts
type BottleSegment = Extract<milky.IncomingSegment, {
  type: 'text' | 'image' | 'video' | 'face' | 'market_face';
}> | (Extract<milky.IncomingSegment, {
  type: 'forward';
}> & {
  data: {
    messages?: milky.IncomingForwardedMessage[];
  };
});
type BottleSignature = {
  type: 'anonymous';
} | {
  type: 'original';
} | {
  type: 'alias';
  name: string;
};
type BottleModerationMode = 'ai' | 'manual';
interface DriftBottleOptions {
  moderationMode?: BottleModerationMode;
  moderationModel?: string;
  ownerIds?: number[];
  /** 兼容旧配置：WebUI 挂载路径已固定为 /webui/drift-bottle，此选项不再生效。 */
  webuiPath?: string;
  /** WebUI 静态资源目录；默认使用构建产物 dist/webui。 */
  webuiDirectory?: string;
}
interface DriftBottle {
  id: string;
  senderId: number;
  createdAt: number;
  displayName?: string;
  source: {
    scene: milky.IncomingMessage['message_scene'];
    peerId: number;
  };
  segments: milky.IncomingSegment[];
}
interface NewDriftBottle {
  senderId: number;
  displayName?: string;
  source: DriftBottle['source'];
  segments: BottleSegment[];
}
interface BottleTextSegmentUpdate {
  segmentIndex: number;
  text: string;
}
type BottleUpdateInput = Pick<NewDriftBottle, 'senderId' | 'displayName' | 'source'> & {
  content?: string;
  textSegments?: BottleTextSegmentUpdate[];
};
type UpdateBottleResult = {
  status: 'updated';
  bottle: DriftBottle;
} | {
  status: 'not-found' | 'content-read-only';
};
interface BottleComment {
  id: string;
  bottleId: string;
  senderId: number;
  createdAt: number;
  displayName?: string;
  content: string;
}
type NewBottleComment = Pick<BottleComment, 'bottleId' | 'senderId' | 'displayName' | 'content'>;
type BottleOperationAction = 'bottle-created' | 'bottle-picked' | 'comment-created' | 'bottle-deleted' | 'bottle-updated' | 'signature-updated' | 'moderator-added' | 'moderator-removed' | 'repeat-pick-updated' | 'moderation-approved' | 'moderation-rejected';
interface BottleOperationRecord {
  id: string;
  createdAt: number;
  action: BottleOperationAction;
  actorId?: number;
  bottleId?: string;
  targetUserId?: number;
  detail?: string;
}
type NewBottleOperationRecord = Omit<BottleOperationRecord, 'id' | 'createdAt'>;
//#endregion
//#region src/processing/moderation.d.ts
interface ModerationResult {
  approved: boolean;
  categories: ('profanity' | 'r18')[];
  reason: string;
  usage?: ModerationUsage;
}
interface ModerationUsage {
  inputTokens?: number;
  outputTokens?: number;
  totalTokens?: number;
}
interface ModerationAttemptDiagnostic {
  responseTextSummary?: string;
  finishReason?: string;
  warnings: string[];
  usage?: ModerationUsage;
}
declare class ModerationFailureError extends Error {
  readonly attempts: ModerationAttemptDiagnostic[];
  readonly usage: ModerationUsage;
  constructor(cause: unknown, attempts: ModerationAttemptDiagnostic[]);
}
type ModerationTarget = 'bottle-content' | 'bottle-signature' | 'comment-content' | 'comment-signature' | 'profile-signature';
interface ModerationContext {
  target: ModerationTarget;
  bottleDraft?: NewDriftBottle;
}
type BottleModerator = (segments: BottleSegment[], context?: ModerationContext) => Promise<ModerationResult>;
//#endregion
//#region src/processing/moderation-records.d.ts
type ModerationProcess = {
  manual: {
    reason: string;
  };
} | {
  result: Pick<ModerationResult, 'approved' | 'categories' | 'reason'>;
} | {
  error: {
    name: string;
    message: string;
    cause?: {
      name: string;
      message: string;
    };
    responseTextSummary?: string;
    finishReason?: string;
    providerWarnings?: string[];
    attempts?: number;
  };
};
interface ModerationRecord {
  id: string;
  createdAt: number;
  content: BottleSegment[];
  process: ModerationProcess;
  inputTokens?: number;
  outputTokens?: number;
  totalTokens?: number;
  success: boolean;
  approved?: boolean;
  target?: ModerationContext['target'];
  bottleDraft?: ModerationContext['bottleDraft'];
  resolution?: 'approved' | 'rejected';
  resolvedBy?: number;
  resolvedAt?: number;
  rejectionReason?: string;
  publishedBottleId?: string;
}
type NewModerationRecord = Omit<ModerationRecord, 'id' | 'createdAt'>;
//#endregion
//#region src/persistence/bottle-store.d.ts
interface PersistedWebuiSettings {
  moderationMode?: BottleModerationMode;
  moderationModel?: string;
  ownerIds: unknown;
  webuiPath: string;
}
type ApproveModerationRecordResult = {
  status: 'approved';
  bottle: DriftBottle;
} | {
  status: 'not-found' | 'already-resolved' | 'not-pending' | 'publish-unavailable';
};
type RejectModerationRecordResult = {
  status: 'rejected';
} | {
  status: 'not-found' | 'already-resolved' | 'not-pending' | 'invalid-reason';
};
declare class BottleStore {
  private readonly database;
  private disposeTestDatabase?;
  constructor(database: Kysely<FraqDatabase>, disposeTestDatabase?: (() => Promise<void>) | undefined);
  dispose(): Promise<void>;
  add(input: NewDriftBottle): Promise<DriftBottle>;
  pick(removeAfterPick: boolean, randomValue?: number): Promise<DriftBottle | undefined>;
  count(): Promise<number>;
  bottles(limit?: number, offset?: number): Promise<DriftBottle[]>;
  bottle(id: string): Promise<DriftBottle | undefined>;
  updateBottle(id: string, input: NewDriftBottle): Promise<DriftBottle | undefined>;
  deleteBottle(id: string): Promise<boolean>;
  hasBottle(id: string): Promise<boolean>;
  isBottleOwner(id: string, userId: number): Promise<boolean>;
  addComment(input: NewBottleComment): Promise<BottleComment | undefined>;
  commentsFor(bottleId: string, limit?: number): Promise<BottleComment[]>;
  commentCount(bottleId: string): Promise<number>;
  addModerator(userId: number): Promise<boolean>;
  removeModerator(userId: number): Promise<boolean>;
  isModerator(userId: number): Promise<boolean>;
  moderators(): Promise<number[]>;
  setRepeatPick(userId: number, enabled?: boolean): Promise<void>;
  repeatPickFor(userId: number): Promise<boolean | undefined>;
  addModerationRecord(input: NewModerationRecord): Promise<ModerationRecord>;
  moderationRecords(limit?: number): Promise<ModerationRecord[]>;
  pendingModerationRecords(limit?: number, offset?: number): Promise<ModerationRecord[]>;
  pendingModerationCount(): Promise<number>;
  approveModerationRecord(id: string, actorId?: number): Promise<ApproveModerationRecordResult>;
  rejectModerationRecord(id: string, actorId: number | undefined, reason: string): Promise<RejectModerationRecordResult>;
  addOperationRecord(input: NewBottleOperationRecord): Promise<BottleOperationRecord>;
  operationRecords(limit?: number): Promise<BottleOperationRecord[]>;
  webuiSettings(): Promise<PersistedWebuiSettings | undefined>;
  setWebuiSettings(settings: Omit<PersistedWebuiSettings, 'ownerIds'> & {
    ownerIds: number[];
  }): Promise<void>;
  setSignature(senderId: number, signature: BottleSignature): Promise<void>;
  signatureFor(senderId: number): Promise<BottleSignature>;
}
//#endregion
//#region src/api/drift-bottle-api.d.ts
type DriftBottleApiErrorCode = 'read-reply' | 'read-forward' | 'moderation' | 'resolve-signature' | 'publish-comment';
declare class DriftBottleApiError extends Error {
  readonly code: DriftBottleApiErrorCode;
  constructor(code: DriftBottleApiErrorCode, options?: ErrorOptions);
}
type CreateBottleResult = {
  status: 'created';
  bottle: DriftBottle;
} | {
  status: 'pending';
  reviewId: string;
} | {
  status: 'empty';
} | {
  status: 'unsupported';
} | {
  status: 'rejected';
  target: 'content' | 'signature';
  reason: string;
};
type PublishCommentResult = {
  status: 'created';
  comment: BottleComment;
} | {
  status: 'not-found';
} | {
  status: 'too-long';
} | {
  status: 'rejected';
  target: 'content' | 'signature';
  reason: string;
};
type UpdateSignatureResult = {
  status: 'updated';
} | {
  status: 'too-long';
} | {
  status: 'rejected';
  reason: string;
};
interface BottleComments {
  comments: BottleComment[];
  total: number;
}
type BottleImageResult = {
  status: 'found';
  url: string;
} | {
  status: 'not-found' | 'not-image' | 'unavailable';
};
declare class DriftBottleApi {
  private readonly client;
  private readonly store;
  private readonly moderator;
  private readonly moderationMode;
  constructor(client: MilkyClient, store: BottleStore, moderator: BottleModerator, moderationMode?: () => BottleModerationMode);
  createBottle(message: milky.IncomingMessage, content: milky.IncomingSegment[]): Promise<CreateBottleResult>;
  pickBottle(userId: number, randomValue?: number): Promise<DriftBottle | undefined>;
  outgoingSegments(bottle: DriftBottle, userId?: number): Promise<milky.OutgoingSegment_ZodInput[]>;
  publishComment(message: milky.IncomingMessage, bottleId: string, content: string): Promise<PublishCommentResult>;
  commentsFor(bottleId: string, limit?: number): Promise<BottleComments | undefined>;
  commentCountFor(bottleId: string): Promise<number>;
  bottleImage(bottleId: string, segmentIndex: number): Promise<BottleImageResult>;
  bottleIdFromReply(reply: Extract<milky.IncomingSegment, {
    type: 'reply';
  }>, message: milky.IncomingMessage): Promise<string | undefined>;
  updateSignature(message: milky.IncomingMessage, signature: BottleSignature): Promise<UpdateSignatureResult>;
  signatureFor(userId: number): Promise<BottleSignature>;
  hasBottle(id: string): Promise<boolean>;
  isBottleOwner(id: string, userId: number): Promise<boolean>;
  deleteBottle(id: string, actorId?: number): Promise<boolean>;
  addModerator(userId: number, actorId?: number): Promise<void>;
  removeModerator(userId: number, actorId?: number): Promise<boolean>;
  isModerator(userId: number): Promise<boolean>;
  moderators(): Promise<number[]>;
  setRepeatPick(userId: number, enabled?: boolean): Promise<void>;
  repeatPickFor(userId: number): Promise<boolean | undefined>;
  moderationRecords(limit?: number): Promise<ModerationRecord[]>;
  pendingModerationRecords(limit?: number, offset?: number): Promise<ModerationRecord[]>;
  pendingModerationCount(): Promise<number>;
  approveModerationRecord(id: string, actorId?: number): Promise<ApproveModerationRecordResult>;
  rejectModerationRecord(id: string, actorId: number | undefined, reason: string): Promise<RejectModerationRecordResult>;
  operationRecords(limit?: number): Promise<BottleOperationRecord[]>;
  add(input: NewDriftBottle, actorId?: number): Promise<DriftBottle>;
  updateBottle(id: string, input: BottleUpdateInput, actorId?: number): Promise<UpdateBottleResult>;
  count(): Promise<number>;
  bottles(limit?: number, offset?: number): Promise<DriftBottle[]>;
  private moderate;
  private resolveSignature;
  private resolveApprovedSignature;
}
//#endregion
//#region src/webui/dashboard.d.ts
interface DashboardRelease {
  version: string;
  items: string[];
}
interface DashboardOperation {
  id: string;
  createdAt: number;
  title: string;
  detail?: string;
  tone: 'neutral' | 'success' | 'warning' | 'danger';
}
interface DashboardRuntimeInfo {
  fraqVersion: string;
  protocolEndpoint?: {
    name: string;
    version: string;
  };
}
interface DashboardSnapshot {
  generatedAt: number;
  instanceStartedAt: number;
  counts: {
    totalBottles: number;
    pendingReview: number;
  };
  changelog: DashboardRelease[];
  operations: DashboardOperation[];
  runtime: DashboardRuntimeInfo;
}
//#endregion
//#region src/webui/lists.d.ts
interface WebuiContentSummary {
  preview: string;
  kinds: string[];
  parts: WebuiContentPart[];
}
interface WebuiContentPart {
  segmentIndex: number;
  text: string;
  faceId?: string;
  imageSegmentIndex?: number;
  forwardMessages?: WebuiForwardMessage[];
  forwardMessageCount?: number;
}
interface WebuiForwardMessage {
  sequence: number;
  sender: string;
  markdown: string;
}
interface WebuiPendingReviewItem {
  id: string;
  createdAt: number;
  content: WebuiContentSummary;
  status: 'pending' | 'rejected' | 'error';
  reason: string;
  categories: string[];
  totalTokens?: number;
  target: string;
  canApprove: boolean;
  bottleDraft?: {
    senderId: number;
    displayName?: string;
    source: {
      scene: string;
      peerId: number;
    };
  };
}
interface WebuiBottleListItem {
  id: string;
  createdAt: number;
  commentCount: number;
  senderId: number;
  displayName?: string;
  editableText?: string;
  editableTextSegments: {
    segmentIndex: number;
    text: string;
  }[];
  content: WebuiContentSummary;
  source: {
    scene: string;
    peerId: number;
  };
}
interface WebuiListPage<T> {
  generatedAt: number;
  page: number;
  pageSize: number;
  total: number;
  totalPages: number;
  items: T[];
}
//#endregion
//#region src/index.d.ts
declare const _default: import("@fraqjs/fraq").Plugin<[options?: DriftBottleOptions | undefined], {
  ai: typeof AiService;
  hono: typeof HonoService;
  kysely: typeof KyselyService;
  webuiGateway: typeof WebuiGatewayService;
}, import("@fraqjs/fraq").Injection | undefined>;
//#endregion
export { type ApproveModerationRecordResult, type BottleComment, type BottleComments, type BottleModerationMode, type BottleOperationAction, type BottleOperationRecord, type BottleSegment, type BottleSignature, type CreateBottleResult, type DashboardOperation, type DashboardRelease, type DashboardRuntimeInfo, type DashboardSnapshot, type DriftBottle, DriftBottleApi, DriftBottleApiError, type DriftBottleApiErrorCode, type DriftBottleOptions, type ModerationAttemptDiagnostic, type ModerationContext, ModerationFailureError, type ModerationProcess, type ModerationRecord, type ModerationTarget, type NewBottleComment, type NewBottleOperationRecord, type NewDriftBottle, type PublishCommentResult, type RejectModerationRecordResult, type UpdateSignatureResult, type WebuiBottleListItem, type WebuiContentSummary, type WebuiListPage, type WebuiPendingReviewItem, _default as default };