fac-shared-db 1.0.0

package/README.md

@@ -0,0 +1,66 @@
+# fac-shared-db
+
+Schemas Mongoose e helper de conexão compartilhados entre os bots do ecossistema (atualmente: `real-street-rp`, `marcar-acao-gta-rp`, `logs-exporter-gta-rp`, `pedir-rec-discord`). Todos os bots conectam direto no mesmo MongoDB Atlas — este pacote existe para que o formato de cada collection seja definido em um único lugar, em vez de duplicado/hand-rolled em cada bot.
+
+## Uso
+
+```ts
+import { connectDatabase, AcaoMarcadaModel } from "fac-shared-db";
+
+await connectDatabase(process.env.MONGO_URI!, "real-street-rp");
+
+const acoes = await AcaoMarcadaModel.find({ resultado: "pendente" });
+```
+
+`connectDatabase(uri, dbName?)` não conhece cluster, host ou `appName` de nenhum bot — cada bot monta sua própria connection string a partir das próprias env vars e decide como reagir a falha de conexão (retry, log, `process.exit`, etc). Isso mantém o pacote agnóstico em relação a qual bot o está consumindo.
+
+## Instalação
+
+Distribuído como dependência git (sem publicação no npm):
+
+```json
+"dependencies": {
+  "fac-shared-db": "git+https://github.com/Weslley08/fac-shared-db.git"
+}
+```
+
+O script `prepare` compila o TypeScript automaticamente após `npm install`.
+
+## Collections
+
+| Model | Collection (Mongo) | Propósito |
+|---|---|---|
+| `AcaoMarcadaModel` | `acaomarcadas` | Ação escalada no canal de escalação (participantes, escalados, resultado) |
+| `AcoesConfigModel` | `acoesconfigs` | Singleton: ações disponíveis + calendário semanal |
+| `AdvertenciaModel` | `advertencias` | Advertências aplicadas a membros (nível, tipo, vencimento) |
+| `AntiGrabberConfigModel` | `antigrabberconfigs` | Singleton: config do anti-spam de anexos |
+| `BindsRoupaConfigModel` | `bindsroupaconfigs` | Singleton: grupos de binds de roupa por cargo |
+| `BlacklistModel` | `blacklist` (override explícito) | Banimento de jogadores, com TTL automático |
+| `BotConfigModel` | `botconfigs` | Singleton: configuração geral do bot |
+| `Caixa2ItemModel` | `caixa2itens` (override explícito) | Itens do baú com limites de advertência |
+| `CanalConfigModel` | `canalconfigs` | Associação de canais lógicos → IDs Discord |
+| `CargoConfigModel` | `cargoconfigs` | Hierarquia/config de cargos |
+| `CraftConfigModel` | `craftconfigs` | Singleton: receitas de craft de munição |
+| `FarmModel` | `farms` | Registro de farm por membro |
+| `FarmValidacaoStateModel` | `farmvalidacaostates` | Estado persistido da validação de farm (TTL 10min) |
+| `FeatureTogglesConfigModel` | `featuretogglesconfigs` | Singleton: feature flags via DB |
+| `MembroCadastroModel` | `membrocadastros` | Cadastro de membro (nome/ID in-game) |
+| `MensagemRecrutamentoModel` | `mensagemrecrutamentos` | Singleton (`_id: "RECRUTAMENTO"`): texto de recrutamento vigente |
+| `MensagemRotacaoModel` | `mensagemrotacaos` | Mensagens que rotacionam em canais |
+| `RegistroOlheiroModel` | `registroolheiros` | Registro de olheiro/recrutamento |
+| `UpRegistroModel` | `upregistros` | Registro de promoção (UP) de membro |
+| `VendaModel` | `vendas` | Registro de venda de munição |
+| `VendaConfigModel` | `vendaconfigs` | Singleton: preços e comissão de venda |
+| `KeyValueModel` | `keyvalues` | Storage genérico key-value |
+| `HistoryModel` | `histories` | Histórico append-only genérico |
+
+Nomes de collection sem "override explícito" são o default do Mongoose (pluralização automática do nome do model) — não dependem de nenhuma string hardcoded neste pacote.
+
+## Quem lê/escreve o quê hoje
+
+- **real-street-rp**: dono de todas as collections acima (cria/atualiza a maioria via painel admin e fluxos internos).
+- **marcar-acao-gta-rp**: escreve em `acaomarcadas` (cria novas ações quando confirmadas via DM).
+- **pedir-rec-discord**: lê `mensagemrecrutamentos` (texto de recrutamento vigente, em vez de hardcoded).
+- **logs-exporter-gta-rp**: escreve em `blacklist` (upsert a partir do parsing de logs) e lê `caixa2itens` (limites de itens monitorados).
+
+Ao adicionar uma collection nova usada por mais de um bot, ela nasce neste pacote — não em um dos bots individualmente.

package/build/connection.d.ts

@@ -0,0 +1,9 @@
+import mongoose from "mongoose";
+/**
+ * Conecta ao MongoDB via Mongoose a partir de uma connection string já montada
+ * pelo bot consumidor. Este pacote não conhece cluster, host ou appName de
+ * nenhum bot específico — cada bot monta sua própria URI a partir das próprias
+ * env vars e decide como lidar com falha de conexão (retry, log, exit, etc).
+ */
+export declare function connectDatabase(uri: string, dbName?: string): Promise<typeof mongoose>;
+export { mongoose };

package/build/connection.js

@@ -0,0 +1,13 @@
+import mongoose from "mongoose";
+/**
+ * Conecta ao MongoDB via Mongoose a partir de uma connection string já montada
+ * pelo bot consumidor. Este pacote não conhece cluster, host ou appName de
+ * nenhum bot específico — cada bot monta sua própria URI a partir das próprias
+ * env vars e decide como lidar com falha de conexão (retry, log, exit, etc).
+ */
+export async function connectDatabase(uri, dbName) {
+    if (mongoose.connection.readyState === 1)
+        return mongoose;
+    return mongoose.connect(uri, dbName ? { dbName } : undefined);
+}
+export { mongoose };

package/build/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./connection.js";
+export * from "./models/index.js";

package/build/index.js

@@ -0,0 +1,2 @@
+export * from "./connection.js";
+export * from "./models/index.js";

package/build/models/AcaoMarcada.d.ts

@@ -0,0 +1,38 @@
+import mongoose, { type Document } from "mongoose";
+/**
+ * Registro de uma ação marcada no sistema de ações.
+ * Cada documento = 1 ação criada no canal de escalação.
+ */
+export interface IAcaoMarcada extends Document {
+    /** Data da ação (dd/mm/yyyy) */
+    data: string;
+    /** Hora da ação (hh:mm) */
+    hora: string;
+    /** Máximo de membros permitidos */
+    maxMembros: number;
+    /** Discord IDs dos interessados (quem clicou em participar) */
+    participantes: string[];
+    /** Discord IDs dos escalados (selecionados pelo líder tático) */
+    escalados: string[];
+    /** Discord ID de quem criou a ação */
+    criadoPor: string;
+    /** Resultado da ação */
+    resultado: "ganhou" | "perdeu" | "pendente";
+    /** ID da mensagem no canal de escalação */
+    mensagemId: string;
+    /** Nome/descrição da ação */
+    nome: string;
+    /** Data de criação */
+    criadoEm: Date;
+    /** Data de finalização (quando resultado foi definido) */
+    finalizadoEm?: Date;
+    /** Data/hora da ação como Date (para queries eficientes no MongoDB) */
+    dataHoraAcao: Date;
+}
+export declare const AcaoMarcadaModel: mongoose.Model<IAcaoMarcada, {}, {}, {}, mongoose.Document<unknown, {}, IAcaoMarcada, {}, mongoose.DefaultSchemaOptions> & IAcaoMarcada & Required<{
+    _id: mongoose.Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, IAcaoMarcada>;

package/build/models/AcaoMarcada.js

@@ -0,0 +1,18 @@
+import mongoose, { Schema } from "mongoose";
+const AcaoMarcadaSchema = new Schema({
+    data: { type: String, required: true },
+    hora: { type: String, required: true },
+    maxMembros: { type: Number, required: true },
+    participantes: { type: [String], default: [] },
+    escalados: { type: [String], default: [] },
+    criadoPor: { type: String, required: true, index: true },
+    resultado: { type: String, default: "pendente", enum: ["ganhou", "perdeu", "pendente"], index: true },
+    nome: { type: String, required: true },
+    mensagemId: { type: String, required: true, unique: true },
+    criadoEm: { type: Date, default: Date.now },
+    finalizadoEm: { type: Date },
+    dataHoraAcao: { type: Date, required: true, index: true },
+});
+// Índice para relatórios por período
+AcaoMarcadaSchema.index({ criadoEm: -1 });
+export const AcaoMarcadaModel = mongoose.model("AcaoMarcada", AcaoMarcadaSchema);

package/build/models/AcoesConfig.d.ts

@@ -0,0 +1,32 @@
+import mongoose, { type Document } from "mongoose";
+/**
+ * Configuração de Ações e Calendário Semanal.
+ * Extraído de BotConfig — uso Singleton via configId fixo ("main").
+ */
+export interface IAcoesConfig extends Document {
+    configId: string;
+    /** Lista de ações disponíveis para marcação */
+    acoesDisponiveis: {
+        chave: string;
+        nome: string;
+        maxParticipantes: number;
+    }[];
+    /** ID do bot externo de marcar ação (DM) */
+    marcarAcaoBotUserId: string;
+    /** Calendário semanal de ações (dia 0=domingo .. 6=sábado) */
+    calendarioSemanal: {
+        dia: number;
+        acaoChave: string;
+        hora: string;
+        escalados: number;
+    }[];
+    /** Data (YYYY-MM-DD) do último envio automático do calendário */
+    calendarioUltimoEnvio: string;
+}
+export declare const AcoesConfigModel: mongoose.Model<IAcoesConfig, {}, {}, {}, mongoose.Document<unknown, {}, IAcoesConfig, {}, mongoose.DefaultSchemaOptions> & IAcoesConfig & Required<{
+    _id: mongoose.Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, IAcoesConfig>;

package/build/models/AcoesConfig.js

@@ -0,0 +1,33 @@
+import mongoose, { Schema } from "mongoose";
+const AcoesConfigSchema = new Schema({
+    configId: { type: String, default: "main", unique: true },
+    acoesDisponiveis: {
+        type: [{
+                chave: { type: String, required: true },
+                nome: { type: String, required: true },
+                maxParticipantes: { type: Number, required: true },
+            }],
+        default: [
+            { chave: "niobio", nome: "Nióbio", maxParticipantes: 15 },
+            { chave: "paleto", nome: "Paleto", maxParticipantes: 6 },
+            { chave: "jojo", nome: "Jojo", maxParticipantes: 8 },
+            { chave: "bc", nome: "BC", maxParticipantes: 12 },
+            { chave: "flecca_life", nome: "Flecca Life", maxParticipantes: 8 },
+            { chave: "flecca_praia", nome: "Flecca Praia", maxParticipantes: 8 },
+            { chave: "flecca_chaves", nome: "Flecca Chaves", maxParticipantes: 8 },
+            { chave: "madereira", nome: "Madereira", maxParticipantes: 10 },
+        ],
+    },
+    marcarAcaoBotUserId: { type: String, default: "1479954523886718997" },
+    calendarioSemanal: {
+        type: [{
+                dia: { type: Number, required: true },
+                acaoChave: { type: String, required: true },
+                hora: { type: String, required: true },
+                escalados: { type: Number, required: true },
+            }],
+        default: [],
+    },
+    calendarioUltimoEnvio: { type: String, default: "" },
+});
+export const AcoesConfigModel = mongoose.model("AcoesConfig", AcoesConfigSchema);

package/build/models/Advertencia.d.ts

@@ -0,0 +1,44 @@
+import mongoose, { type Document } from "mongoose";
+/**
+ * Registro de advertência aplicada a um membro.
+ * Cada documento = 1 advertência.
+ */
+/** Tipo/categoria da advertência */
+export type TipoAdvertencia = "caixa2" | "farm" | "outros";
+export interface IAdvertencia extends Document {
+    /** Discord ID do membro advertido */
+    membroId: string;
+    /** Nome in-game no momento da ADV */
+    nomeInGame: string;
+    /** ID in-game no momento da ADV */
+    idInGame: string;
+    /** Nível da ADV (1, 2 ou 3) */
+    nivel: 1 | 2 | 3;
+    /** Tipo/categoria da advertência */
+    tipo: TipoAdvertencia;
+    /** Motivo da advertência */
+    motivo: string;
+    /** Link de evidência (opcional) */
+    evidencia?: string;
+    /** Discord ID de quem aplicou */
+    aplicadoPor: string;
+    /** Se a ADV ainda está ativa ou foi removida */
+    ativa: boolean;
+    /** Data de aplicação */
+    criadoEm: Date;
+    /** Data de expiração automática (ADVs antigas podem não ter) */
+    expiraEm?: Date;
+    /** Data em que expirou de fato (se expirou) */
+    expiradaEm?: Date;
+    /** Data de remoção (se removida manualmente) */
+    removidoEm?: Date;
+    /** Quem removeu (se removida manualmente) */
+    removidoPor?: string;
+}
+export declare const AdvertenciaModel: mongoose.Model<IAdvertencia, {}, {}, {}, mongoose.Document<unknown, {}, IAdvertencia, {}, mongoose.DefaultSchemaOptions> & IAdvertencia & Required<{
+    _id: mongoose.Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, IAdvertencia>;

package/build/models/Advertencia.js

@@ -0,0 +1,20 @@
+import mongoose, { Schema } from "mongoose";
+const AdvertenciaSchema = new Schema({
+    membroId: { type: String, required: true, index: true },
+    nomeInGame: { type: String, required: true },
+    idInGame: { type: String, required: true },
+    nivel: { type: Number, required: true, enum: [1, 2, 3] },
+    tipo: { type: String, required: true, enum: ["caixa2", "farm", "outros"], default: "outros" },
+    motivo: { type: String, required: true },
+    evidencia: { type: String },
+    aplicadoPor: { type: String, required: true },
+    ativa: { type: Boolean, default: true, index: true },
+    criadoEm: { type: Date, default: Date.now },
+    expiraEm: { type: Date, index: true },
+    expiradaEm: { type: Date },
+    removidoEm: { type: Date },
+    removidoPor: { type: String },
+});
+// Índice composto para buscar ADVs ativas de um membro rapidamente
+AdvertenciaSchema.index({ membroId: 1, ativa: 1 });
+export const AdvertenciaModel = mongoose.model("Advertencia", AdvertenciaSchema);

package/build/models/AntiGrabberConfig.d.ts

@@ -0,0 +1,24 @@
+import mongoose, { type Document } from "mongoose";
+/**
+ * Configurações do sistema Anti-Grabber.
+ * Coleção própria — segregada do BotConfig.
+ * Uso Singleton via configId fixo ("main").
+ */
+export interface IAntiGrabberConfig extends Document {
+    configId: string;
+    /** IDs de canais ignorados (anexos não disparam a detecção) */
+    canaisIgnorados: string[];
+    /** Janela de tempo (segundos) para agrupar mensagens do mesmo usuário */
+    janelaSegundos: number;
+    /** Mínimo de canais distintos com anexo na janela para acionar a detecção */
+    minCanais: number;
+    /** Duração do timeout aplicado ao membro (horas) */
+    timeoutHoras: number;
+}
+export declare const AntiGrabberConfigModel: mongoose.Model<IAntiGrabberConfig, {}, {}, {}, mongoose.Document<unknown, {}, IAntiGrabberConfig, {}, mongoose.DefaultSchemaOptions> & IAntiGrabberConfig & Required<{
+    _id: mongoose.Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, IAntiGrabberConfig>;

package/build/models/AntiGrabberConfig.js

@@ -0,0 +1,9 @@
+import mongoose, { Schema } from "mongoose";
+const AntiGrabberConfigSchema = new Schema({
+    configId: { type: String, default: "main", unique: true },
+    canaisIgnorados: { type: [String], default: [] },
+    janelaSegundos: { type: Number, default: 8 },
+    minCanais: { type: Number, default: 3 },
+    timeoutHoras: { type: Number, default: 24 },
+});
+export const AntiGrabberConfigModel = mongoose.model("AntiGrabberConfig", AntiGrabberConfigSchema);

package/build/models/BindsRoupaConfig.d.ts

@@ -0,0 +1,29 @@
+import mongoose, { type Document } from "mongoose";
+/**
+ * Configuração de Binds de Roupa.
+ * Extraído de BotConfig — uso Singleton via configId fixo ("main").
+ */
+export interface IBindsRoupaConfig extends Document {
+    configId: string;
+    /** Grupos de cargos (100% configuráveis via painel admin), cada um com presets de roupa masculino/feminino */
+    bindsRoupaGrupos: {
+        id: string;
+        label: string;
+        cargoKeys: string[];
+        masculino: {
+            imagemUrl: string;
+            bindTexto: string;
+        };
+        feminino: {
+            imagemUrl: string;
+            bindTexto: string;
+        };
+    }[];
+}
+export declare const BindsRoupaConfigModel: mongoose.Model<IBindsRoupaConfig, {}, {}, {}, mongoose.Document<unknown, {}, IBindsRoupaConfig, {}, mongoose.DefaultSchemaOptions> & IBindsRoupaConfig & Required<{
+    _id: mongoose.Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, IBindsRoupaConfig>;

package/build/models/BindsRoupaConfig.js

@@ -0,0 +1,21 @@
+import mongoose, { Schema } from "mongoose";
+const BindsRoupaConfigSchema = new Schema({
+    configId: { type: String, default: "main", unique: true },
+    bindsRoupaGrupos: {
+        type: [{
+                id: { type: String, required: true },
+                label: { type: String, required: true },
+                cargoKeys: { type: [String], default: [] },
+                masculino: {
+                    imagemUrl: { type: String, default: "" },
+                    bindTexto: { type: String, default: "" },
+                },
+                feminino: {
+                    imagemUrl: { type: String, default: "" },
+                    bindTexto: { type: String, default: "" },
+                },
+            }],
+        default: [],
+    },
+});
+export const BindsRoupaConfigModel = mongoose.model("BindsRoupaConfig", BindsRoupaConfigSchema);

package/build/models/Blacklist.d.ts

@@ -0,0 +1,16 @@
+import mongoose, { type Document } from "mongoose";
+export interface IBlacklist extends Document {
+    playerId: string;
+    organizacao?: string;
+    cargo?: string;
+    vencimento: Date;
+    criadoEm: Date;
+    atualizadoEm: Date;
+}
+export declare const BlacklistModel: mongoose.Model<IBlacklist, {}, {}, {}, mongoose.Document<unknown, {}, IBlacklist, {}, mongoose.DefaultSchemaOptions> & IBlacklist & Required<{
+    _id: mongoose.Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, IBlacklist>;

package/build/models/Blacklist.js

@@ -0,0 +1,10 @@
+import mongoose, { Schema } from "mongoose";
+const BlacklistSchema = new Schema({
+    playerId: { type: String, required: true, unique: true },
+    organizacao: { type: String },
+    cargo: { type: String },
+    vencimento: { type: Date, required: true, index: { expireAfterSeconds: 0 } },
+    criadoEm: { type: Date, default: Date.now },
+    atualizadoEm: { type: Date, default: Date.now },
+});
+export const BlacklistModel = mongoose.model("Blacklist", BlacklistSchema, "blacklist");

package/build/models/BotConfig.d.ts

@@ -0,0 +1,72 @@
+import mongoose, { type Document } from "mongoose";
+/**
+ * Configurações dinâmicas do bot (salvas no MongoDB).
+ * Apenas UM documento deve existir — uso Singleton via configId fixo.
+ */
+export interface CargoHierarchyConfigEntry {
+    key: string;
+    /** ID do cargo no Discord (quando sincronizado do servidor) */
+    discordRoleId?: string;
+    nome: string;
+    sigla: string;
+    ordem: number;
+    /** Tags de permissão/grupo ativas para este cargo */
+    tags: string[];
+}
+export interface IBotConfig extends Document {
+    configId: string;
+    /** Overrides dos IDs de cargos usados pelo sistema (chave lógica → roleId Discord) */
+    cargoIds: Map<string, string>;
+    farmDiasVencimento: number;
+    rebaixamentoDiasRecrutador: number;
+    rebaixamentoDiasMembro: number;
+    farmDiaVencimentoGerencia: number;
+    recrutamentoValorPorAprovacao: number;
+    mensagensAutoTimestamps: Map<string, Date>;
+    /** Horário (HH:mm) em que mensagens automáticas são enviadas */
+    mensagensAutoHorarioEnvio: string;
+    /** Requisitos de itens por tipo de farm (parametrizável via painel admin) */
+    farmRequisitos: {
+        tipo: string;
+        label: string;
+        itens: {
+            nomes: string[];
+            quantidade: number;
+            acao: string;
+        }[];
+    }[];
+    /** Data da última execução da limpeza de blacklist */
+    ultimaLimpezaBlacklist: Date | null;
+    /** Intervalo (em horas) entre execuções da limpeza de blacklist */
+    limpezaBlacklistIntervaloHoras: number;
+    /** Dias até uma advertência (ADV) expirar automaticamente */
+    advDiasExpiracao: number;
+    /** IDs de canais onde links são permitidos (todos os outros bloqueiam) */
+    antiLinkCanaisPermitidos: string[];
+    /** Domínios liberados globalmente no anti-link (independente de canal) */
+    antiLinkDominiosPermitidos: string[];
+    /** Data da última execução da verificação de caixa2 líder */
+    ultimaExecucaoCaixa2Lider: Date | null;
+    /** Proporção mínima (0-1) que o líder deve manter no caixa2 */
+    caixa2LiderProporcaoMinima: number;
+    /** Membros com cargos fixos especiais (discordId → array de cargo keys). Configurável via painel admin. */
+    cargosEspeciais: Map<string, string[]>;
+    canaisIds: Map<string, string>;
+    /** Dias de retenção de logs do bot no MongoDB */
+    logTtlDias: number;
+    /** Última vez que o bot estava online (atualizado periodicamente) */
+    lastOnlineAt: Date | null;
+    /** Metas semanais de recs+ups por cargo de gerência, com redução de farm */
+    metasRecrutamento: {
+        cargoKey: string;
+        metaSemanal: number;
+        reducaoFarmPercent: number;
+    }[];
+}
+export declare const BotConfigModel: mongoose.Model<IBotConfig, {}, {}, {}, mongoose.Document<unknown, {}, IBotConfig, {}, mongoose.DefaultSchemaOptions> & IBotConfig & Required<{
+    _id: mongoose.Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, IBotConfig>;

package/build/models/BotConfig.js

@@ -0,0 +1,66 @@
+import mongoose, { Schema } from "mongoose";
+const BotConfigSchema = new Schema({
+    configId: { type: String, default: "main", unique: true },
+    // Cargos
+    cargoIds: { type: Map, of: String, default: new Map() },
+    // Farm
+    farmDiasVencimento: { type: Number, default: 7 },
+    // Rebaixamento
+    rebaixamentoDiasRecrutador: { type: Number, default: 14 },
+    rebaixamentoDiasMembro: { type: Number, default: 1 },
+    // Gerência
+    farmDiaVencimentoGerencia: { type: Number, default: 1 }, // 1 = segunda-feira
+    // Recrutamento
+    recrutamentoValorPorAprovacao: { type: Number, default: 150_000 },
+    // Mensagens automáticas
+    mensagensAutoTimestamps: { type: Map, of: Date, default: new Map() },
+    mensagensAutoHorarioEnvio: { type: String, default: "17:00" },
+    // Validação de Farm
+    farmRequisitos: {
+        type: [{
+                tipo: { type: String, required: true },
+                label: { type: String, required: true },
+                itens: {
+                    type: [{
+                            nomes: { type: [String], required: true },
+                            quantidade: { type: Number, required: true },
+                            acao: { type: String, required: true },
+                        }],
+                    default: [],
+                },
+            }],
+        default: [],
+    },
+    // Blacklist
+    ultimaLimpezaBlacklist: { type: Date, default: null },
+    limpezaBlacklistIntervaloHoras: { type: Number, default: 12 },
+    advDiasExpiracao: { type: Number, default: 30 },
+    // Anti-Link — Canais (IDs)
+    antiLinkCanaisPermitidos: { type: [String], default: [] },
+    antiLinkDominiosPermitidos: { type: [String], default: ["medal.tv"] },
+    // Caixa2 Líder
+    ultimaExecucaoCaixa2Lider: { type: Date, default: null },
+    caixa2LiderProporcaoMinima: { type: Number, default: 0.3 },
+    // Cargos Especiais
+    cargosEspeciais: { type: Map, of: [String], default: new Map() },
+    // Canais
+    canaisIds: { type: Map, of: String, default: new Map() },
+    // Retenção de Dados
+    logTtlDias: { type: Number, default: 30 },
+    // Metas de Recrutamento
+    metasRecrutamento: {
+        type: [{
+                cargoKey: { type: String, required: true },
+                metaSemanal: { type: Number, required: true },
+                reducaoFarmPercent: { type: Number, required: true },
+            }],
+        default: [
+            { cargoKey: "GERENTE_RECRUTADOR", metaSemanal: 5, reducaoFarmPercent: 0.30 },
+            { cargoKey: "GERENTE_PRODUÇÃO", metaSemanal: 7, reducaoFarmPercent: 0.40 },
+            { cargoKey: "GERENTE_GERAL", metaSemanal: 10, reducaoFarmPercent: 0.50 },
+        ],
+    },
+    // Heartbeat
+    lastOnlineAt: { type: Date, default: null },
+});
+export const BotConfigModel = mongoose.model("BotConfig", BotConfigSchema);

package/build/models/Caixa2Item.d.ts

@@ -0,0 +1,14 @@
+import mongoose, { type Document } from "mongoose";
+export interface ICaixa2Item extends Document {
+    nome: string;
+    emoji: string;
+    minAdv: number;
+    maxAdv: number;
+}
+export declare const Caixa2ItemModel: mongoose.Model<ICaixa2Item, {}, {}, {}, mongoose.Document<unknown, {}, ICaixa2Item, {}, mongoose.DefaultSchemaOptions> & ICaixa2Item & Required<{
+    _id: mongoose.Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, ICaixa2Item>;

package/build/models/Caixa2Item.js

@@ -0,0 +1,8 @@
+import mongoose, { Schema } from "mongoose";
+const Caixa2ItemSchema = new Schema({
+    nome: { type: String, required: true, unique: true },
+    emoji: { type: String, required: true },
+    minAdv: { type: Number, required: true },
+    maxAdv: { type: Number, required: true },
+}, { collection: "caixa2itens" });
+export const Caixa2ItemModel = mongoose.model("Caixa2Item", Caixa2ItemSchema);

package/build/models/CanalConfig.d.ts

@@ -0,0 +1,19 @@
+export interface ICanalConfig {
+    /** Chave lógica usada como _id (ex: "CANAL_ENTREGA_FARM") */
+    _id: string;
+    /** ID do canal Discord (snowflake). Vazio = não configurado */
+    channelId: string;
+    /** Label para exibição no painel admin */
+    label: string;
+    /** Descrição da funcionalidade do canal */
+    descricao: string;
+    /** Nome exato do canal no Discord para auto-detect */
+    discordName: string;
+}
+export declare const CanalConfigModel: import("mongoose").Model<ICanalConfig, {}, {}, {}, import("mongoose").Document<unknown, {}, ICanalConfig, {}, import("mongoose").DefaultSchemaOptions> & ICanalConfig & Required<{
+    _id: string;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, ICanalConfig>;

package/build/models/CanalConfig.js

@@ -0,0 +1,9 @@
+import { Schema, model } from "mongoose";
+const CanalConfigSchema = new Schema({
+    _id: { type: String },
+    channelId: { type: String, default: "" },
+    label: { type: String, required: true },
+    descricao: { type: String, required: true },
+    discordName: { type: String, default: "" },
+}, { timestamps: false, versionKey: false });
+export const CanalConfigModel = model("CanalConfig", CanalConfigSchema);

package/build/models/CargoConfig.d.ts

@@ -0,0 +1,18 @@
+import mongoose, { type Document } from "mongoose";
+export interface ICargoConfig extends Document {
+    key: string;
+    /** ID do cargo no Discord (quando sincronizado do servidor) */
+    discordRoleId: string;
+    nome: string;
+    sigla: string;
+    ordem: number;
+    /** Tags de permissão/grupo ativas para este cargo */
+    tags: string[];
+}
+export declare const CargoConfigModel: mongoose.Model<ICargoConfig, {}, {}, {}, mongoose.Document<unknown, {}, ICargoConfig, {}, mongoose.DefaultSchemaOptions> & ICargoConfig & Required<{
+    _id: mongoose.Types.ObjectId;
+}> & {
+    __v: number;
+} & {
+    id: string;
+}, any, ICargoConfig>;

package/build/models/CargoConfig.js

@@ -0,0 +1,12 @@
+import mongoose, { Schema } from "mongoose";
+const CargoConfigSchema = new Schema({
+    key: { type: String, required: true, unique: true },
+    discordRoleId: { type: String, default: "" },
+    nome: { type: String, required: true },
+    sigla: { type: String, default: "" },
+    ordem: { type: Number, required: true },
+    tags: { type: [String], default: [] },
+}, { timestamps: true, strict: false });
+CargoConfigSchema.index({ discordRoleId: 1 });
+CargoConfigSchema.index({ ordem: 1 });
+export const CargoConfigModel = mongoose.model("CargoConfig", CargoConfigSchema);