agent-relay 1.6.0 → 2.0.4

package/packages/cloud/dist/billing/plans.js

@@ -0,0 +1,245 @@
+/**
+ * Agent Relay Cloud - Billing Plans
+ *
+ * Plan definitions for subscription tiers.
+ */
+/**
+ * All available billing plans
+ */
+export const BILLING_PLANS = {
+    free: {
+        id: 'free',
+        name: 'Free',
+        description: 'Try AI agent workflows with limited access',
+        priceMonthly: 0,
+        priceYearly: 0,
+        limits: {
+            maxWorkspaces: 1,
+            maxAgentsPerWorkspace: 2,
+            maxTeamMembers: 1,
+            maxStorageGB: 1,
+            maxComputeHoursPerMonth: 5, // Limited to 5 hours/month
+            customDomains: false,
+            prioritySupport: false,
+            sla: false,
+            ssoEnabled: false,
+            auditLogs: false,
+            sessionPersistence: false,
+        },
+        features: [
+            '1 workspace',
+            'Up to 2 agents',
+            '5 compute hours/month',
+            'Shared CPU (may throttle)',
+            'Community support',
+        ],
+    },
+    pro: {
+        id: 'pro',
+        name: 'Pro',
+        description: 'For professional developers building with AI agents',
+        priceMonthly: 6900, // $69/month
+        priceYearly: 69000, // $690/year (2 months free)
+        stripePriceIdMonthly: process.env.STRIPE_PRO_MONTHLY_PRICE_ID,
+        stripePriceIdYearly: process.env.STRIPE_PRO_YEARLY_PRICE_ID,
+        limits: {
+            maxWorkspaces: 5,
+            maxAgentsPerWorkspace: 5,
+            maxTeamMembers: 3,
+            maxStorageGB: 10,
+            maxComputeHoursPerMonth: 50,
+            customDomains: true,
+            prioritySupport: false,
+            sla: false,
+            ssoEnabled: false,
+            auditLogs: false,
+            sessionPersistence: true,
+        },
+        features: [
+            'Up to 5 workspaces',
+            'Up to 5 agents per workspace',
+            '50 compute hours/month',
+            '10 GB storage',
+            '3 team members',
+            'Custom domains',
+            'Session persistence',
+            'Email support',
+        ],
+    },
+    team: {
+        id: 'team',
+        name: 'Team',
+        description: 'For growing teams with advanced needs',
+        priceMonthly: 12900, // $129/month
+        priceYearly: 129000, // $1290/year (2 months free)
+        stripePriceIdMonthly: process.env.STRIPE_TEAM_MONTHLY_PRICE_ID,
+        stripePriceIdYearly: process.env.STRIPE_TEAM_YEARLY_PRICE_ID,
+        limits: {
+            maxWorkspaces: 50,
+            maxAgentsPerWorkspace: 25,
+            maxTeamMembers: 25,
+            maxStorageGB: 50,
+            maxComputeHoursPerMonth: 500,
+            customDomains: true,
+            prioritySupport: true,
+            sla: false,
+            ssoEnabled: false,
+            auditLogs: true,
+            sessionPersistence: true,
+        },
+        features: [
+            'Up to 50 workspaces',
+            'Up to 25 agents per workspace',
+            '500 compute hours/month',
+            '50 GB storage',
+            '25 team members',
+            'Custom domains',
+            'Session persistence',
+            'Priority support',
+            'Audit logs',
+        ],
+    },
+    enterprise: {
+        id: 'enterprise',
+        name: 'Enterprise',
+        description: 'For organizations requiring dedicated support and SLAs',
+        priceMonthly: 49900, // $499/month starting
+        priceYearly: 499000, // $4990/year
+        stripePriceIdMonthly: process.env.STRIPE_ENTERPRISE_MONTHLY_PRICE_ID,
+        stripePriceIdYearly: process.env.STRIPE_ENTERPRISE_YEARLY_PRICE_ID,
+        limits: {
+            maxWorkspaces: -1, // unlimited
+            maxAgentsPerWorkspace: -1, // unlimited
+            maxTeamMembers: -1, // unlimited
+            maxStorageGB: 500,
+            maxComputeHoursPerMonth: -1, // unlimited
+            customDomains: true,
+            prioritySupport: true,
+            sla: true,
+            ssoEnabled: true,
+            auditLogs: true,
+            sessionPersistence: true,
+        },
+        features: [
+            'Unlimited workspaces',
+            'Unlimited agents',
+            'Unlimited compute hours',
+            '500 GB storage',
+            'Unlimited team members',
+            'Custom domains',
+            'Session persistence',
+            'Priority support with SLA',
+            'SSO/SAML integration',
+            'Audit logs & compliance',
+            'Dedicated account manager',
+        ],
+    },
+};
+/**
+ * Get plan by ID
+ */
+export function getPlan(tier) {
+    return BILLING_PLANS[tier];
+}
+/**
+ * Get all plans as array
+ */
+export function getAllPlans() {
+    return Object.values(BILLING_PLANS);
+}
+/**
+ * Check if a limit is within plan bounds
+ * Returns true if the value is within limits (-1 means unlimited)
+ */
+export function isWithinLimit(limit, current) {
+    if (limit === -1)
+        return true; // unlimited
+    return current < limit;
+}
+/**
+ * Get the next tier upgrade from current
+ */
+export function getUpgradeTier(current) {
+    const tiers = ['free', 'pro', 'team', 'enterprise'];
+    const currentIndex = tiers.indexOf(current);
+    if (currentIndex === -1 || currentIndex >= tiers.length - 1) {
+        return null;
+    }
+    return tiers[currentIndex + 1];
+}
+/**
+ * Format price for display
+ */
+export function formatPrice(cents) {
+    if (cents === 0)
+        return 'Free';
+    return `$${(cents / 100).toFixed(0)}`;
+}
+/**
+ * Get plan limits comparison
+ */
+export function comparePlans(from, to) {
+    const fromPlan = BILLING_PLANS[from];
+    const toPlan = BILLING_PLANS[to];
+    const upgrades = [];
+    const downgrades = [];
+    // Compare limits
+    const compareLimit = (name, fromVal, toVal) => {
+        if (toVal === -1 && fromVal !== -1) {
+            upgrades.push(`Unlimited ${name}`);
+        }
+        else if (fromVal === -1 && toVal !== -1) {
+            downgrades.push(`${name} limited to ${toVal}`);
+        }
+        else if (toVal > fromVal) {
+            upgrades.push(`${name}: ${fromVal} -> ${toVal}`);
+        }
+        else if (toVal < fromVal) {
+            downgrades.push(`${name}: ${fromVal} -> ${toVal}`);
+        }
+    };
+    compareLimit('workspaces', fromPlan.limits.maxWorkspaces, toPlan.limits.maxWorkspaces);
+    compareLimit('agents per workspace', fromPlan.limits.maxAgentsPerWorkspace, toPlan.limits.maxAgentsPerWorkspace);
+    compareLimit('team members', fromPlan.limits.maxTeamMembers, toPlan.limits.maxTeamMembers);
+    compareLimit('storage GB', fromPlan.limits.maxStorageGB, toPlan.limits.maxStorageGB);
+    compareLimit('compute hours', fromPlan.limits.maxComputeHoursPerMonth, toPlan.limits.maxComputeHoursPerMonth);
+    // Compare boolean features
+    if (toPlan.limits.customDomains && !fromPlan.limits.customDomains) {
+        upgrades.push('Custom domains');
+    }
+    else if (!toPlan.limits.customDomains && fromPlan.limits.customDomains) {
+        downgrades.push('Custom domains');
+    }
+    if (toPlan.limits.prioritySupport && !fromPlan.limits.prioritySupport) {
+        upgrades.push('Priority support');
+    }
+    else if (!toPlan.limits.prioritySupport && fromPlan.limits.prioritySupport) {
+        downgrades.push('Priority support');
+    }
+    if (toPlan.limits.sla && !fromPlan.limits.sla) {
+        upgrades.push('SLA');
+    }
+    else if (!toPlan.limits.sla && fromPlan.limits.sla) {
+        downgrades.push('SLA');
+    }
+    if (toPlan.limits.ssoEnabled && !fromPlan.limits.ssoEnabled) {
+        upgrades.push('SSO/SAML');
+    }
+    else if (!toPlan.limits.ssoEnabled && fromPlan.limits.ssoEnabled) {
+        downgrades.push('SSO/SAML');
+    }
+    if (toPlan.limits.auditLogs && !fromPlan.limits.auditLogs) {
+        upgrades.push('Audit logs');
+    }
+    else if (!toPlan.limits.auditLogs && fromPlan.limits.auditLogs) {
+        downgrades.push('Audit logs');
+    }
+    if (toPlan.limits.sessionPersistence && !fromPlan.limits.sessionPersistence) {
+        upgrades.push('Session persistence');
+    }
+    else if (!toPlan.limits.sessionPersistence && fromPlan.limits.sessionPersistence) {
+        downgrades.push('Session persistence');
+    }
+    return { upgrades, downgrades };
+}
+//# sourceMappingURL=plans.js.map

package/packages/cloud/dist/config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @deprecated Import from '@agent-relay/config/cloud-config' instead.
+ */
+export * from '@agent-relay/config/cloud-config';
+//# sourceMappingURL=config.d.ts.map

package/packages/cloud/dist/config.js

@@ -0,0 +1,5 @@
+/**
+ * @deprecated Import from '@agent-relay/config/cloud-config' instead.
+ */
+export * from '@agent-relay/config/cloud-config';
+//# sourceMappingURL=config.js.map

package/packages/cloud/dist/db/drizzle.d.ts

@@ -0,0 +1,256 @@
+/**
+ * Agent Relay Cloud - Drizzle Database Client
+ *
+ * Type-safe database access using Drizzle ORM.
+ * Use this instead of the raw pg client for new code.
+ */
+import { Pool } from 'pg';
+import * as schema from './schema.js';
+export type { User, NewUser, GitHubInstallation, NewGitHubInstallation, Credential, NewCredential, Workspace, NewWorkspace, WorkspaceConfig, WorkspaceMember, NewWorkspaceMember, ProjectGroup, NewProjectGroup, CoordinatorAgentConfig, ProjectAgentConfig, Repository, NewRepository, LinkedDaemon, NewLinkedDaemon, Subscription, NewSubscription, UsageRecord, NewUsageRecord, AgentSession, NewAgentSession, AgentSummary, NewAgentSummary, } from './schema.js';
+export * from './schema.js';
+/**
+ * Get the raw connection pool for bulk operations.
+ * Use this for optimized bulk inserts that bypass the ORM.
+ */
+export declare function getRawPool(): Pool;
+export declare function getDb(): import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, unknown>> & {
+    $client: Pool;
+};
+export interface UserQueries {
+    findById(id: string): Promise<schema.User | null>;
+    findByGithubId(githubId: string): Promise<schema.User | null>;
+    findByGithubUsername(username: string): Promise<schema.User | null>;
+    findByEmail(email: string): Promise<schema.User | null>;
+    findByNangoConnectionId(connectionId: string): Promise<schema.User | null>;
+    findByIncomingConnectionId(connectionId: string): Promise<schema.User | null>;
+    findByPlan(plan: string): Promise<schema.User[]>;
+    upsert(data: schema.NewUser): Promise<schema.User>;
+    update(id: string, data: Partial<Omit<schema.User, 'id' | 'createdAt'>>): Promise<void>;
+    completeOnboarding(userId: string): Promise<void>;
+    clearIncomingConnectionId(userId: string): Promise<void>;
+    setPendingInstallationRequest(userId: string): Promise<void>;
+    clearPendingInstallationRequest(userId: string): Promise<void>;
+}
+export declare const userQueries: UserQueries;
+export interface GitHubInstallationQueries {
+    findById(id: string): Promise<schema.GitHubInstallation | null>;
+    findByInstallationId(installationId: string): Promise<schema.GitHubInstallation | null>;
+    findByAccountLogin(accountLogin: string): Promise<schema.GitHubInstallation | null>;
+    findByInstalledBy(userId: string): Promise<schema.GitHubInstallation[]>;
+    findAll(): Promise<schema.GitHubInstallation[]>;
+    upsert(data: schema.NewGitHubInstallation): Promise<schema.GitHubInstallation>;
+    updatePermissions(installationId: string, permissions: Record<string, string>, events: string[]): Promise<void>;
+    suspend(installationId: string, suspendedBy: string): Promise<void>;
+    unsuspend(installationId: string): Promise<void>;
+    delete(installationId: string): Promise<void>;
+}
+export declare const githubInstallationQueries: GitHubInstallationQueries;
+export interface CredentialQueries {
+    /** Get all credentials for a user (across all workspaces) */
+    findByUserId(userId: string): Promise<schema.Credential[]>;
+    /** Get all credentials for a user in a specific workspace */
+    findByUserAndWorkspace(userId: string, workspaceId: string): Promise<schema.Credential[]>;
+    /** Get a specific provider credential for a user in a workspace */
+    findByUserWorkspaceAndProvider(userId: string, workspaceId: string, provider: string): Promise<schema.Credential | null>;
+    /** @deprecated Use findByUserWorkspaceAndProvider for workspace-scoped queries */
+    findByUserAndProvider(userId: string, provider: string): Promise<schema.Credential | null>;
+    /** Upsert credential (unique on userId + provider + workspaceId) */
+    upsert(data: schema.NewCredential): Promise<schema.Credential>;
+    /** Delete credential for a specific workspace */
+    deleteForWorkspace(userId: string, workspaceId: string, provider: string): Promise<void>;
+    /** @deprecated Use deleteForWorkspace for workspace-scoped deletions */
+    delete(userId: string, provider: string): Promise<void>;
+}
+export declare const credentialQueries: CredentialQueries;
+export interface WorkspaceQueries {
+    findById(id: string): Promise<schema.Workspace | null>;
+    findByUserId(userId: string): Promise<schema.Workspace[]>;
+    findByCustomDomain(domain: string): Promise<schema.Workspace | null>;
+    findByRepoFullName(repoFullName: string): Promise<schema.Workspace | null>;
+    findAll(): Promise<schema.Workspace[]>;
+    create(data: schema.NewWorkspace): Promise<schema.Workspace>;
+    update(id: string, data: Partial<Pick<schema.Workspace, 'name' | 'config'>>): Promise<void>;
+    updateStatus(id: string, status: string, options?: {
+        computeId?: string;
+        publicUrl?: string;
+        errorMessage?: string;
+    }): Promise<void>;
+    updateConfig(id: string, config: schema.WorkspaceConfig): Promise<void>;
+    setCustomDomain(id: string, customDomain: string, status?: string): Promise<void>;
+    updateCustomDomainStatus(id: string, status: string): Promise<void>;
+    removeCustomDomain(id: string): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+export declare const workspaceQueries: WorkspaceQueries;
+export interface WorkspaceMemberQueries {
+    findByWorkspaceId(workspaceId: string): Promise<schema.WorkspaceMember[]>;
+    findByUserId(userId: string): Promise<schema.WorkspaceMember[]>;
+    findMembership(workspaceId: string, userId: string): Promise<schema.WorkspaceMember | null>;
+    addMember(data: {
+        workspaceId: string;
+        userId: string;
+        role: string;
+        invitedBy: string;
+    }): Promise<schema.WorkspaceMember>;
+    acceptInvite(workspaceId: string, userId: string): Promise<void>;
+    updateRole(workspaceId: string, userId: string, role: string): Promise<void>;
+    removeMember(workspaceId: string, userId: string): Promise<void>;
+    getPendingInvites(userId: string): Promise<schema.WorkspaceMember[]>;
+    isOwner(workspaceId: string, userId: string): Promise<boolean>;
+    canEdit(workspaceId: string, userId: string): Promise<boolean>;
+    canView(workspaceId: string, userId: string): Promise<boolean>;
+}
+export declare const workspaceMemberQueries: WorkspaceMemberQueries;
+export interface DaemonAgentInfo {
+    daemonId: string;
+    daemonName: string;
+    machineId: string;
+    agents: Array<{
+        name: string;
+        status: string;
+    }>;
+}
+export interface DaemonUpdate {
+    type: string;
+    payload: unknown;
+}
+export interface LinkedDaemonQueries {
+    findById(id: string): Promise<schema.LinkedDaemon | null>;
+    findByUserId(userId: string): Promise<schema.LinkedDaemon[]>;
+    findByWorkspaceId(workspaceId: string): Promise<schema.LinkedDaemon[]>;
+    findByMachineId(userId: string, machineId: string): Promise<schema.LinkedDaemon | null>;
+    findByApiKeyHash(apiKeyHash: string): Promise<schema.LinkedDaemon | null>;
+    create(data: schema.NewLinkedDaemon): Promise<schema.LinkedDaemon>;
+    update(id: string, data: Partial<schema.LinkedDaemon>): Promise<void>;
+    updateLastSeen(id: string): Promise<void>;
+    delete(id: string): Promise<void>;
+    markStale(): Promise<number>;
+    getAllAgentsForUser(userId: string): Promise<DaemonAgentInfo[]>;
+    getPendingUpdates(id: string): Promise<DaemonUpdate[]>;
+    queueUpdate(id: string, update: DaemonUpdate): Promise<void>;
+    queueMessage(id: string, message: Record<string, unknown>): Promise<void>;
+    getQueuedMessages(id: string): Promise<Array<Record<string, unknown>>>;
+    clearMessageQueue(id: string): Promise<void>;
+}
+export declare const linkedDaemonQueries: LinkedDaemonQueries;
+export interface ProjectGroupWithRepositories extends schema.ProjectGroup {
+    repositories: schema.Repository[];
+}
+export interface AllGroupsResult {
+    groups: ProjectGroupWithRepositories[];
+    ungroupedRepositories: schema.Repository[];
+}
+export interface ProjectGroupQueries {
+    findById(id: string): Promise<schema.ProjectGroup | null>;
+    findByUserId(userId: string): Promise<schema.ProjectGroup[]>;
+    findByName(userId: string, name: string): Promise<schema.ProjectGroup | null>;
+    create(data: schema.NewProjectGroup): Promise<schema.ProjectGroup>;
+    update(id: string, data: Partial<Omit<schema.ProjectGroup, 'id' | 'userId' | 'createdAt'>>): Promise<void>;
+    delete(id: string): Promise<void>;
+    findWithRepositories(id: string): Promise<ProjectGroupWithRepositories | null>;
+    findAllWithRepositories(userId: string): Promise<AllGroupsResult>;
+    updateCoordinatorAgent(id: string, config: schema.CoordinatorAgentConfig): Promise<void>;
+    reorder(userId: string, orderedIds: string[]): Promise<void>;
+}
+export declare const projectGroupQueries: ProjectGroupQueries;
+export interface RepositoryQueries {
+    findById(id: string): Promise<schema.Repository | null>;
+    findByFullName(fullName: string): Promise<schema.Repository | null>;
+    findByGithubFullName(fullName: string): Promise<schema.Repository[]>;
+    findByUserId(userId: string): Promise<schema.Repository[]>;
+    findByWorkspaceId(workspaceId: string): Promise<schema.Repository[]>;
+    findByProjectGroupId(projectGroupId: string): Promise<schema.Repository[]>;
+    upsert(data: schema.NewRepository): Promise<schema.Repository>;
+    assignToWorkspace(repoId: string, workspaceId: string | null): Promise<void>;
+    assignToGroup(repoId: string, projectGroupId: string | null): Promise<void>;
+    updateProjectAgent(id: string, config: schema.ProjectAgentConfig): Promise<void>;
+    updateSyncStatus(id: string, status: string, lastSyncedAt?: Date): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+export declare const repositoryQueries: RepositoryQueries;
+export interface AgentSessionQueries {
+    findById(id: string): Promise<schema.AgentSession | null>;
+    findByWorkspaceId(workspaceId: string): Promise<schema.AgentSession[]>;
+    findActiveByWorkspace(workspaceId: string): Promise<schema.AgentSession[]>;
+    create(data: schema.NewAgentSession): Promise<schema.AgentSession>;
+    endSession(id: string, endMarker?: {
+        summary?: string;
+        completedTasks?: string[];
+    }): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+export declare const agentSessionQueries: AgentSessionQueries;
+export interface AgentSummaryQueries {
+    findBySessionId(sessionId: string): Promise<schema.AgentSummary[]>;
+    findLatestByAgent(agentName: string): Promise<schema.AgentSummary | null>;
+    create(data: schema.NewAgentSummary): Promise<schema.AgentSummary>;
+    deleteBySession(sessionId: string): Promise<void>;
+}
+export declare const agentSummaryQueries: AgentSummaryQueries;
+export interface CIFailureEventQueries {
+    findById(id: string): Promise<schema.CIFailureEvent | null>;
+    findByRepository(repository: string, limit?: number): Promise<schema.CIFailureEvent[]>;
+    findByPR(repository: string, prNumber: number): Promise<schema.CIFailureEvent[]>;
+    findRecentUnprocessed(limit?: number): Promise<schema.CIFailureEvent[]>;
+    create(data: schema.NewCIFailureEvent): Promise<schema.CIFailureEvent>;
+    markProcessed(id: string, agentSpawned: boolean): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+export declare const ciFailureEventQueries: CIFailureEventQueries;
+export interface CIFixAttemptQueries {
+    findById(id: string): Promise<schema.CIFixAttempt | null>;
+    findByFailureEvent(failureEventId: string): Promise<schema.CIFixAttempt[]>;
+    findActiveByRepository(repository: string): Promise<schema.CIFixAttempt[]>;
+    create(data: schema.NewCIFixAttempt): Promise<schema.CIFixAttempt>;
+    updateStatus(id: string, status: string, errorMessage?: string): Promise<void>;
+    complete(id: string, status: 'success' | 'failed', commitSha?: string, errorMessage?: string): Promise<void>;
+}
+export declare const ciFixAttemptQueries: CIFixAttemptQueries;
+export interface IssueAssignmentQueries {
+    findById(id: string): Promise<schema.IssueAssignment | null>;
+    findByRepository(repository: string, limit?: number): Promise<schema.IssueAssignment[]>;
+    findByIssue(repository: string, issueNumber: number): Promise<schema.IssueAssignment | null>;
+    findByAgent(agentId: string): Promise<schema.IssueAssignment[]>;
+    findPending(limit?: number): Promise<schema.IssueAssignment[]>;
+    create(data: schema.NewIssueAssignment): Promise<schema.IssueAssignment>;
+    assignAgent(id: string, agentId: string, agentName: string): Promise<void>;
+    updateStatus(id: string, status: string, resolution?: string): Promise<void>;
+    linkPR(id: string, prNumber: number): Promise<void>;
+}
+export declare const issueAssignmentQueries: IssueAssignmentQueries;
+export interface CommentMentionQueries {
+    findById(id: string): Promise<schema.CommentMention | null>;
+    findByRepository(repository: string, limit?: number): Promise<schema.CommentMention[]>;
+    findBySource(sourceType: string, sourceId: number): Promise<schema.CommentMention | null>;
+    findPending(limit?: number): Promise<schema.CommentMention[]>;
+    findByMentionedAgent(mentionedAgent: string, limit?: number): Promise<schema.CommentMention[]>;
+    create(data: schema.NewCommentMention): Promise<schema.CommentMention>;
+    markProcessing(id: string, agentId: string, agentName: string): Promise<void>;
+    markResponded(id: string, responseCommentId: number, responseBody: string): Promise<void>;
+    markIgnored(id: string): Promise<void>;
+}
+export declare const commentMentionQueries: CommentMentionQueries;
+export interface ChannelQueries {
+    findById(id: string): Promise<schema.Channel | null>;
+    findByWorkspaceId(workspaceId: string): Promise<schema.Channel[]>;
+    findByWorkspaceAndChannelId(workspaceId: string, channelId: string): Promise<schema.Channel | null>;
+    create(channel: schema.NewChannel): Promise<schema.Channel>;
+    update(id: string, updates: Partial<schema.NewChannel>): Promise<void>;
+    archive(id: string): Promise<void>;
+    unarchive(id: string): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+export declare const channelQueries: ChannelQueries;
+export interface ChannelMemberQueries {
+    findByChannelId(channelId: string): Promise<schema.ChannelMember[]>;
+    findByMemberId(memberId: string): Promise<schema.ChannelMember[]>;
+    findMembership(channelId: string, memberId: string): Promise<schema.ChannelMember | null>;
+    addMember(member: schema.NewChannelMember): Promise<schema.ChannelMember>;
+    removeMember(channelId: string, memberId: string): Promise<void>;
+    updateRole(channelId: string, memberId: string, role: string): Promise<void>;
+    countByChannelIds(channelIds: string[]): Promise<Map<string, number>>;
+}
+export declare const channelMemberQueries: ChannelMemberQueries;
+export declare function runMigrations(): Promise<void>;
+export declare function closeDb(): Promise<void>;
+//# sourceMappingURL=drizzle.d.ts.map