import * as convex_server from 'convex/server';
import * as convex_values from 'convex/values';
import { AnalyticsStorageAdapter } from '@geenius/analytics';

/**
 * @module ConvexMutations
 * @package @geenius/analytics/convex
 * @description Mutation collection for inserting analytics events, page views,
 * identity traits, and derived analytics artifacts into the packaged tables.
 */
/** Mutation that inserts a normalized analytics event into the packaged events table. */
declare const trackEvent: convex_server.RegisteredMutation<"public", {
    properties?: Record<string, string | number | boolean | null> | undefined;
    userId?: string | undefined;
    traits?: Record<string, string | number | boolean | null> | undefined;
    id: string;
    type: string;
    device: {
        browser: string;
        os: string;
        device: "desktop" | "tablet" | "mobile";
        screenWidth: number;
        screenHeight: number;
        language: string;
    };
    sessionId: string;
    name: string;
    url: string;
    referrer: string;
    timestamp: number;
}, Promise<convex_values.GenericId<"analytics_events">>>;
/** Mutation that inserts a normalized page-view record into the packaged pageviews table. */
declare const trackPageView: convex_server.RegisteredMutation<"public", {
    properties?: Record<string, string | number | boolean | null> | undefined;
    userId?: string | undefined;
    duration?: number | undefined;
    sessionId: string;
    url: string;
    referrer: string;
    timestamp: number;
    title: string;
}, Promise<convex_values.GenericId<"analytics_pageviews">>>;
/** Mutation that upserts analytics user traits keyed by external user identifier. */
declare const identifyUser: convex_server.RegisteredMutation<"public", {
    userId: string;
    traits: Record<string, string | number | boolean | null>;
}, Promise<null>>;
/** Mutation that merges profile traits for an existing or newly identified user. */
declare const setUserProperties: convex_server.RegisteredMutation<"public", {
    userId: string;
    traits: Record<string, string | number | boolean | null>;
}, Promise<null>>;
/** Mutation that persists evaluated funnel-analysis results for later querying. */
declare const storeFunnelResult: convex_server.RegisteredMutation<"public", {
    name: string;
    steps: {
        properties?: Record<string, string | number | boolean | null> | undefined;
        name: string;
        event: string;
    }[];
    totalEntries: number;
    totalConversions: number;
    overallConversionRate: number;
    results: {
        name: string;
        event: string;
        count: number;
        dropoffRate: number;
        conversionRate: number;
    }[];
}, Promise<convex_values.GenericId<"analytics_funnels">>>;
/** Mutation that persists generated cohort analyses for later querying. */
declare const storeCohortAnalysis: convex_server.RegisteredMutation<"public", {
    name: string;
    cohortType: "user" | "session";
    intervals: number[];
    cohorts: {
        cohort: string;
        size: number;
        retained: {
            day: number;
            retainedUsers: number;
            retentionRate: number;
        }[];
        lastActivity: number;
    }[];
}, Promise<convex_values.GenericId<"analytics_cohorts">>>;
/** Mutation that stores a normalized session-replay snapshot for a session identifier. */
declare const storeSessionReplay: convex_server.RegisteredMutation<"public", {
    userId?: string | undefined;
    sessionId: string;
    duration: number;
    startedAt: number;
    endedAt: number;
    frames: {
        properties?: Record<string, string | number | boolean | null> | undefined;
        userId?: string | undefined;
        id: string;
        sessionId: string;
        url: string;
        timestamp: number;
        kind: "event" | "page_view";
        label: string;
        deltaMs: number;
    }[];
    activePages: string[];
}, Promise<convex_values.GenericId<"analytics_session_replays">>>;
/** Mutation that deletes all analytics data for a given user (right-to-forget compliance). */
declare const deleteUserData: convex_server.RegisteredMutation<"public", {
    userId: string;
}, Promise<null>>;
/** Mutation that deletes analytics rows older than the supplied retention cutoff. */
declare const purgeExpiredData: convex_server.RegisteredMutation<"public", {
    cutoffTimestamp: number;
}, Promise<null>>;

declare const mutations_deleteUserData: typeof deleteUserData;
declare const mutations_identifyUser: typeof identifyUser;
declare const mutations_purgeExpiredData: typeof purgeExpiredData;
declare const mutations_setUserProperties: typeof setUserProperties;
declare const mutations_storeCohortAnalysis: typeof storeCohortAnalysis;
declare const mutations_storeFunnelResult: typeof storeFunnelResult;
declare const mutations_storeSessionReplay: typeof storeSessionReplay;
declare const mutations_trackEvent: typeof trackEvent;
declare const mutations_trackPageView: typeof trackPageView;
declare namespace mutations {
  export { mutations_deleteUserData as deleteUserData, mutations_identifyUser as identifyUser, mutations_purgeExpiredData as purgeExpiredData, mutations_setUserProperties as setUserProperties, mutations_storeCohortAnalysis as storeCohortAnalysis, mutations_storeFunnelResult as storeFunnelResult, mutations_storeSessionReplay as storeSessionReplay, mutations_trackEvent as trackEvent, mutations_trackPageView as trackPageView };
}

/**
 * @module ConvexQueries
 * @package @geenius/analytics/convex
 * @description Query collection for packaged analytics read models, including
 * event streams, top-page aggregates, realtime snapshots, cohort analysis, and
 * session replay materialization.
 */
type CohortRetentionPoint = {
    day: number;
    retainedUsers: number;
    retentionRate: number;
};
type CohortBucket = {
    cohort: string;
    size: number;
    retained: CohortRetentionPoint[];
    lastActivity: number;
};
type CohortAnalysisResult = {
    name: string;
    cohortType: "user" | "session";
    intervals: number[];
    cohorts: CohortBucket[];
    generatedAt: number;
};
/** Query that returns normalized analytics events filtered by time range and optional user identity. */
declare const getEvents: convex_server.RegisteredQuery<"public", {
    userId?: string | undefined;
    startTime?: number | undefined;
    endTime?: number | undefined;
    limit?: number | undefined;
}, Promise<{
    id: string;
    sessionId: string;
    name: string;
    type: string;
    properties: Record<string, string | number | boolean | null> | undefined;
    url: string;
    referrer: string;
    userId: string | undefined;
    traits: Record<string, string | number | boolean | null> | undefined;
    device: {
        browser: string;
        os: string;
        device: "desktop" | "tablet" | "mobile";
        screenWidth: number;
        screenHeight: number;
        language: string;
    };
    timestamp: number;
}[]>>;
/** Query that returns normalized page-view records filtered by time range. */
declare const getPageViews: convex_server.RegisteredQuery<"public", {
    startTime?: number | undefined;
    endTime?: number | undefined;
    limit?: number | undefined;
}, Promise<{
    url: string;
    title: string;
    referrer: string;
    properties: Record<string, string | number | boolean | null> | undefined;
    duration: number | undefined;
    sessionId: string;
    userId: string | undefined;
    timestamp: number;
}[]>>;
/** Query that aggregates the most-viewed pages from recent page-view rows. */
declare const getTopPages: convex_server.RegisteredQuery<"public", {
    limit?: number | undefined;
}, Promise<{
    url: string;
    views: number;
}[]>>;
/** Query that aggregates device usage across recent analytics events. */
declare const getDeviceBreakdown: convex_server.RegisteredQuery<"public", {}, Promise<{
    desktop: number;
    tablet: number;
    mobile: number;
}>>;
/** Query that returns stored funnel-analysis records, optionally filtered by name. */
declare const getFunnelResults: convex_server.RegisteredQuery<"public", {
    name?: string | undefined;
}, Promise<{
    name: string;
    steps: {
        name: string;
        event: string;
        count: number;
        dropoffRate: number;
        conversionRate: number;
    }[];
    totalEntries: number;
    totalConversions: number;
    overallConversionRate: number;
    analyzedAt: number;
}[]>>;
/** Query that derives a realtime analytics snapshot from recently tracked events. */
declare const getRealtimeStats: convex_server.RegisteredQuery<"public", {}, Promise<{
    activeVisitors: number;
    currentPageViews: number;
    activeSessions: number;
    eventsPerSecond: number;
    conversions: number;
    conversionRate: number;
    deviceBreakdown: {
        desktop: number;
        tablet: number;
        mobile: number;
    };
    topActivePages: {
        url: string;
        visitors: number;
    }[];
    lastUpdated: number;
}>>;
/** Query that returns stored or on-demand generated cohort analysis data. */
declare const getCohortAnalysis: convex_server.RegisteredQuery<"public", {
    name?: string | undefined;
    cohortType?: "user" | "session" | undefined;
    intervals?: number[] | undefined;
}, Promise<CohortAnalysisResult>>;
/** Query that returns a stored or on-demand generated session-replay snapshot. */
declare const getSessionReplay: convex_server.RegisteredQuery<"public", {
    sessionId: string;
}, Promise<{
    sessionId: string;
    startedAt: number;
    endedAt: number;
    duration: number;
    frames: {
        properties?: Record<string, string | number | boolean | null> | undefined;
        userId?: string | undefined;
        id: string;
        sessionId: string;
        url: string;
        timestamp: number;
        kind: "event" | "page_view";
        label: string;
        deltaMs: number;
    }[];
    activePages: string[];
    userId: string | undefined;
}>>;

declare const queries_getCohortAnalysis: typeof getCohortAnalysis;
declare const queries_getDeviceBreakdown: typeof getDeviceBreakdown;
declare const queries_getEvents: typeof getEvents;
declare const queries_getFunnelResults: typeof getFunnelResults;
declare const queries_getPageViews: typeof getPageViews;
declare const queries_getRealtimeStats: typeof getRealtimeStats;
declare const queries_getSessionReplay: typeof getSessionReplay;
declare const queries_getTopPages: typeof getTopPages;
declare namespace queries {
  export { queries_getCohortAnalysis as getCohortAnalysis, queries_getDeviceBreakdown as getDeviceBreakdown, queries_getEvents as getEvents, queries_getFunnelResults as getFunnelResults, queries_getPageViews as getPageViews, queries_getRealtimeStats as getRealtimeStats, queries_getSessionReplay as getSessionReplay, queries_getTopPages as getTopPages };
}

/**
 * @module ConvexAnalyticsStore
 * @package @geenius/analytics/convex
 * @description AnalyticsStorageAdapter wrapper for Convex clients. The factory
 * lets the shared tracker persist sanitized events through packaged Convex
 * mutations while preserving the same read-model contract as other DB backends.
 */

/**
 * Minimal Convex client contract required by the analytics storage adapter.
 *
 * @property mutation Invokes a packaged Convex mutation reference with arguments.
 * @property query Invokes a packaged Convex query reference with arguments.
 */
interface ConvexAnalyticsClient {
    mutation(functionReference: unknown, args: Record<string, unknown>): Promise<unknown>;
    query<TResult = unknown>(functionReference: unknown, args: Record<string, unknown>): Promise<TResult>;
}
/**
 * Options for creating a Convex-backed analytics storage adapter.
 *
 * @property client Convex client bound to the consumer application deployment.
 */
interface ConvexAnalyticsStoreOptions {
    client: ConvexAnalyticsClient;
}
/**
 * Creates a Convex-backed storage adapter for the shared analytics tracker.
 *
 * Use this when an application already has a Convex client and wants
 * `createTracker({ storage })` to persist through the packaged Convex
 * mutations and queries instead of hand-written glue code.
 *
 * @param options Convex client options for the target deployment.
 * @returns An AnalyticsStorageAdapter backed by packaged Convex functions.
 *
 * @example
 * ```ts
 * const storage = createConvexAnalyticsStore({ client: convex })
 * const tracker = createTracker({ storage })
 * ```
 */
declare function createConvexAnalyticsStore(options: ConvexAnalyticsStoreOptions): AnalyticsStorageAdapter;

type store_ConvexAnalyticsClient = ConvexAnalyticsClient;
type store_ConvexAnalyticsStoreOptions = ConvexAnalyticsStoreOptions;
declare const store_createConvexAnalyticsStore: typeof createConvexAnalyticsStore;
declare namespace store {
  export { type store_ConvexAnalyticsClient as ConvexAnalyticsClient, type store_ConvexAnalyticsStoreOptions as ConvexAnalyticsStoreOptions, store_createConvexAnalyticsStore as createConvexAnalyticsStore };
}

export { type ConvexAnalyticsClient as C, type ConvexAnalyticsStoreOptions as a, getDeviceBreakdown as b, createConvexAnalyticsStore as c, deleteUserData as d, getEvents as e, getFunnelResults as f, getCohortAnalysis as g, getPageViews as h, getRealtimeStats as i, getSessionReplay as j, getTopPages as k, identifyUser as l, storeCohortAnalysis as m, storeFunnelResult as n, storeSessionReplay as o, purgeExpiredData as p, trackPageView as q, mutations as r, setUserProperties as s, trackEvent as t, queries as u, store as v };