import * as i0 from '@angular/core';
import { InjectionToken, EnvironmentProviders } from '@angular/core';

type ThreadplaneTelemetryEvent = 'tplane:browser_provided' | 'tplane:browser_chat_init' | 'tplane:runtime_instance_created' | 'tplane:runtime_request_created' | 'tplane:stream_started' | 'tplane:stream_ended' | 'tplane:stream_errored';
interface ThreadplaneTelemetryEventPayload {
    event: ThreadplaneTelemetryEvent;
    properties?: Record<string, unknown>;
}
type ThreadplaneTelemetrySink = (payload: ThreadplaneTelemetryEventPayload) => void | Promise<void>;
interface ThreadplaneTelemetryConfig {
    enabled: boolean;
    /**
     * Preferred app-owned delivery hook. Use this when the consuming app wants
     * to forward events through its own analytics boundary.
     */
    sink?: ThreadplaneTelemetrySink;
    /**
     * Preferred app-owned ingest URL. The browser service POSTs neutral event
     * payloads here; the endpoint decides where they ultimately go.
     */
    endpoint?: string;
    /** @deprecated Prefer sink or endpoint so public app code is vendor-neutral. */
    posthogKey?: string;
    /** @deprecated Prefer sink or endpoint so public app code is vendor-neutral. */
    posthogHost?: string;
    sampleRate?: number;
}
declare const THREADPLANE_TELEMETRY_CONFIG: InjectionToken<ThreadplaneTelemetryConfig | null>;

/**
 * Provide browser telemetry configuration for an Angular app.
 *
 * Browser telemetry remains off unless this provider is installed with
 * `enabled: true`. Delivery goes through `sink`, `endpoint`, or the legacy
 * PostHog options configured on `ThreadplaneTelemetryConfig`.
 */
declare function provideThreadplaneTelemetry(config: ThreadplaneTelemetryConfig): EnvironmentProviders;

type ThreadplaneBrowserEvent = ThreadplaneTelemetryEvent;
/** Runtime lifecycle properties captured from browser-side agent adapters. */
interface ThreadplaneBrowserRuntimeTelemetry {
    /** Runtime transport, such as `langgraph` or `ag-ui`. */
    transport: string;
    /** Optional product or app surface tag. */
    surface?: string;
    /** Optional model provider name. */
    provider?: string;
    /** Optional model name. */
    model?: string;
}
/** Stream telemetry properties captured from browser-side agent adapters. */
interface ThreadplaneBrowserStreamTelemetry extends ThreadplaneBrowserRuntimeTelemetry {
    /** Stream duration in milliseconds, when known. */
    durationMs?: number;
}
/** Stream error telemetry. The raw error is reduced to an error class. */
interface ThreadplaneBrowserStreamErrorTelemetry extends ThreadplaneBrowserStreamTelemetry {
    /** Raw error object or value; capture sends only `errorClass`. */
    error?: unknown;
}
/**
 * Browser-side telemetry service.
 *
 * The service no-ops unless `provideThreadplaneTelemetry({ enabled: true })`
 * configured it. It enriches sent events with `sample_weight`, then delivers
 * them through `sink`, `endpoint`, or legacy PostHog configuration.
 */
declare class ThreadplaneTelemetryService {
    private config;
    private postHogPromise;
    private distinctId;
    /** Capture an arbitrary enabled browser telemetry event. */
    capture(event: ThreadplaneTelemetryEvent, properties?: Record<string, unknown>): Promise<void>;
    /** Capture a runtime construction event. */
    captureRuntimeInstanceCreated(input: ThreadplaneBrowserRuntimeTelemetry): Promise<void>;
    /** Capture a runtime request creation event. */
    captureRuntimeRequestCreated(input: ThreadplaneBrowserRuntimeTelemetry & {
        requestType: string;
    }): Promise<void>;
    /** Capture a stream-start event. */
    captureStreamStarted(input: ThreadplaneBrowserStreamTelemetry): Promise<void>;
    /** Capture a stream-end event. */
    captureStreamEnded(input: ThreadplaneBrowserStreamTelemetry): Promise<void>;
    /** Capture a stream-error event, sending only the derived error class. */
    captureStreamErrored(input: ThreadplaneBrowserStreamErrorTelemetry): Promise<void>;
    private captureEndpoint;
    private getDistinctId;
    private loadPostHog;
    static ɵfac: i0.ɵɵFactoryDeclaration<ThreadplaneTelemetryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ThreadplaneTelemetryService>;
}

type CaptureConfig = {
    token?: string;
    captureLocal?: boolean;
    host?: string;
};
declare function isLocalAnalyticsHost(host: unknown): boolean;
declare function shouldCaptureAnalytics({ token, captureLocal, host }: CaptureConfig): boolean;

type DevelopmentIntegration = 'langgraph' | 'ag-ui' | 'render';
type DevelopmentMilestone = 'transport.connected' | 'runtime.first_stream_completed' | 'thread.persisted' | 'interrupt.handled' | 'generative_ui.rendered';
interface DevelopmentRuntimeOptions {
    integration: DevelopmentIntegration;
    packageName: '@threadplane/langgraph' | '@threadplane/ag-ui' | '@threadplane/render';
    packageVersion: string;
    /** Opaque package-local correlation, never identity or authorization. */
    installationToken?: string | null;
    enabled?: () => boolean;
}
interface DevelopmentRuntime {
    touch(): void;
    milestone(kind: DevelopmentMilestone, durationMs?: number): void;
    dispose(): void;
}

/** Optional subtree policy, evaluated at use time. App-owned render trees may provide this token. */
declare const DEVELOPMENT_COLLECTION_POLICY: InjectionToken<() => boolean>;
/** Immediately stops automatic development collection and clears pending work in this page. */
declare function setDevelopmentCollectionEnabled(value: boolean): void;
/** Aggregate local counters only; never returns identities or event content. */
declare function getDevelopmentCollectionDiagnostics(): {
    pending: number;
    discarded: number;
    failures: number;
    acknowledged: number;
};
/** @internal Carries adapter destination policy to nested supported renderers. */
declare function registerDevelopmentRuntimePolicy<T extends object>(agent: T, policy: () => boolean): T;
/** @internal Unknown app-owned agents do not opt nested renderers into a second destination. */
declare function isDevelopmentRuntimeEnabled(agent: object): boolean;
/** Inert until an integration calls touch() or reports a milestone; never initialize this at module import. */
declare function createDevelopmentRuntime(options: DevelopmentRuntimeOptions): DevelopmentRuntime;

export { DEVELOPMENT_COLLECTION_POLICY, THREADPLANE_TELEMETRY_CONFIG, ThreadplaneTelemetryService, createDevelopmentRuntime, getDevelopmentCollectionDiagnostics, isDevelopmentRuntimeEnabled, isLocalAnalyticsHost, provideThreadplaneTelemetry, registerDevelopmentRuntimePolicy, setDevelopmentCollectionEnabled, shouldCaptureAnalytics };
export type { CaptureConfig, DevelopmentMilestone, DevelopmentRuntime, DevelopmentRuntimeOptions, ThreadplaneBrowserEvent, ThreadplaneBrowserRuntimeTelemetry, ThreadplaneBrowserStreamErrorTelemetry, ThreadplaneBrowserStreamTelemetry, ThreadplaneTelemetryConfig, ThreadplaneTelemetryEvent, ThreadplaneTelemetryEventPayload, ThreadplaneTelemetrySink };
//# sourceMappingURL=threadplane-telemetry.d.ts.map