@blyp/core 0.1.2

package/dist/types/connectors/betterstack.d.ts

@@ -0,0 +1,54 @@
+import type { BlypConnectorsConfig, ResolvedBetterStackConnectorConfig } from '../core/config';
+import type { LogRecord } from '../core/file-logger';
+import type { BlypLogger } from '../core/logger';
+import type { ConnectorMode } from './mode';
+import type { SentryModuleLike } from './sentry';
+export interface BetterStackLoggerConfig {
+    connectors?: BlypConnectorsConfig;
+}
+export interface BetterStackLogger extends BlypLogger {
+}
+export interface BetterStackExceptionCaptureOptions {
+    source?: BetterStackLogSource;
+    warnIfUnavailable?: boolean;
+    context?: Record<string, unknown>;
+}
+export interface BetterStackErrorTracker {
+    capture: (error: unknown, options?: BetterStackExceptionCaptureOptions) => void;
+    child: (bindings: Record<string, unknown>) => BetterStackErrorTracker;
+}
+export type BetterStackLogSource = 'server' | 'client';
+export interface BetterStackSendOptions {
+    source?: BetterStackLogSource;
+    warnIfUnavailable?: boolean;
+}
+export interface BetterStackClientLike {
+    log: (message: string, level: string, context?: Record<string, unknown>) => Promise<unknown>;
+    flush: () => Promise<unknown>;
+}
+export interface BetterStackTestHooks {
+    createClient?: (config: ResolvedBetterStackConnectorConfig) => BetterStackClientLike;
+    module?: SentryModuleLike;
+}
+export interface BetterStackSender {
+    readonly enabled: boolean;
+    readonly ready: boolean;
+    readonly mode: ConnectorMode;
+    readonly serviceName: string;
+    readonly ingestingHost?: string;
+    readonly status: 'enabled' | 'missing';
+    readonly errorTracking: {
+        enabled: boolean;
+        ready: boolean;
+        status: 'enabled' | 'missing';
+        dsn?: string;
+        tracesSampleRate: number;
+        environment?: string;
+        release?: string;
+    };
+    shouldAutoForwardServerLogs: () => boolean;
+    shouldAutoCaptureExceptions: () => boolean;
+    send: (record: LogRecord, options?: BetterStackSendOptions) => void;
+    captureException: (error: unknown, options?: BetterStackExceptionCaptureOptions) => void;
+    flush: () => Promise<void>;
+}

package/dist/types/connectors/mode.d.ts

@@ -0,0 +1,2 @@
+/** Connector integration mode. Extend via union if needed (e.g. ConnectorMode | 'custom'). */
+export type ConnectorMode = 'auto' | 'manual';

package/dist/types/connectors/otlp.d.ts

@@ -0,0 +1,50 @@
+import type { SeverityNumber } from '@opentelemetry/api-logs';
+import type { BlypConnectorsConfig, ResolvedOTLPConnectorConfig } from '../core/config';
+import type { LogRecord } from '../core/file-logger';
+import type { BlypLogger } from '../core/logger';
+import type { ConnectorMode } from './mode';
+export interface OTLPLoggerConfig {
+    name: string;
+    connectors?: BlypConnectorsConfig;
+}
+export interface OTLPLogger extends BlypLogger {
+}
+export type OTLPLogSource = 'server' | 'client';
+export interface OTLPTransport {
+    emit: (payload: OTLPNormalizedRecord) => void | Promise<void>;
+    flush?: () => Promise<void>;
+    shutdown?: () => Promise<void>;
+}
+export interface OTLPSendOptions {
+    source?: OTLPLogSource;
+    warnIfUnavailable?: boolean;
+}
+export interface OTLPNormalizedRecord {
+    body: string;
+    severityText: string;
+    severityNumber: SeverityNumber;
+    attributes: Record<string, unknown>;
+    resourceAttributes: {
+        'service.name': string;
+    };
+}
+export interface OTLPSender {
+    readonly name: string;
+    readonly enabled: boolean;
+    readonly ready: boolean;
+    readonly mode: ConnectorMode;
+    readonly serviceName: string;
+    readonly endpoint?: string;
+    readonly status: 'enabled' | 'missing';
+    send: (record: LogRecord, options?: OTLPSendOptions) => void;
+    flush: () => Promise<void>;
+}
+export interface OTLPRegistry {
+    get: (name: string) => OTLPSender;
+    getAutoForwardTargets: () => OTLPSender[];
+    send: (name: string, record: LogRecord, options?: OTLPSendOptions) => void;
+    flush: () => Promise<void>;
+}
+export interface OTLPTestHooks {
+    createTransport?: (config: ResolvedOTLPConnectorConfig) => OTLPTransport;
+}

package/dist/types/connectors/posthog.d.ts

@@ -0,0 +1,75 @@
+import type { SeverityNumber } from '@opentelemetry/api-logs';
+import type { BlypConnectorsConfig, ResolvedPostHogConnectorConfig } from '../core/config';
+import type { LogRecord } from '../core/file-logger';
+import type { BlypLogger } from '../core/logger';
+import type { ConnectorMode } from './mode';
+export interface PostHogLoggerConfig {
+    connectors?: BlypConnectorsConfig;
+}
+export interface PostHogLogger extends BlypLogger {
+}
+export interface PostHogExceptionCaptureOptions {
+    distinctId?: string;
+    properties?: Record<string, unknown>;
+}
+export interface PostHogErrorTracker {
+    capture: (error: unknown, options?: PostHogExceptionCaptureOptions) => void;
+    child: (bindings: Record<string, unknown>) => PostHogErrorTracker;
+}
+export type PostHogSource = 'server' | 'client';
+export interface PostHogLogTransport {
+    emit: (payload: PostHogNormalizedRecord) => void | Promise<void>;
+    flush?: () => Promise<void>;
+    shutdown?: () => Promise<void>;
+}
+export interface PostHogExceptionClient {
+    captureException: (error: unknown, distinctId?: string, additionalProperties?: Record<string | number, unknown>) => void | Promise<void>;
+    shutdown?: () => Promise<void>;
+}
+export interface PostHogSendOptions {
+    source?: PostHogSource;
+    warnIfUnavailable?: boolean;
+}
+export interface PostHogCaptureExceptionOptions {
+    source?: PostHogSource;
+    warnIfUnavailable?: boolean;
+    distinctId?: string;
+    properties?: Record<string, unknown>;
+}
+export interface PostHogNormalizedRecord {
+    body: string;
+    severityText: string;
+    severityNumber: SeverityNumber;
+    attributes: Record<string, unknown>;
+    resourceAttributes: {
+        'service.name': string;
+    };
+}
+export interface PostHogSender {
+    readonly enabled: boolean;
+    readonly ready: boolean;
+    readonly mode: ConnectorMode;
+    readonly serviceName: string;
+    readonly host: string;
+    readonly status: 'enabled' | 'missing';
+    readonly errorTracking: {
+        enabled: boolean;
+        ready: boolean;
+        mode: ConnectorMode;
+        status: 'enabled' | 'missing';
+        enableExceptionAutocapture: boolean;
+    };
+    shouldAutoForwardServerLogs: () => boolean;
+    shouldAutoCaptureExceptions: () => boolean;
+    send: (record: LogRecord, options?: PostHogSendOptions) => void;
+    captureException: (error: unknown, options?: PostHogCaptureExceptionOptions) => void;
+    flush: () => Promise<void>;
+}
+export interface PostHogTestHooks {
+    createTransport?: (config: ResolvedPostHogConnectorConfig) => PostHogLogTransport;
+    createExceptionClient?: (config: ResolvedPostHogConnectorConfig) => PostHogExceptionClient;
+}
+export interface NormalizedPostHogException {
+    error: Error;
+    properties: Record<string, unknown>;
+}

package/dist/types/connectors/sentry.d.ts

@@ -0,0 +1,48 @@
+import type { Scope } from '@sentry/node';
+import type { BlypConnectorsConfig } from '../core/config';
+import type { LogRecord } from '../core/file-logger';
+import type { BlypLogger } from '../core/logger';
+import type { ConnectorMode } from './mode';
+export interface SentryLoggerConfig {
+    connectors?: BlypConnectorsConfig;
+}
+export interface SentryLogger extends BlypLogger {
+}
+export type SentryLogSource = 'server' | 'client';
+export interface SentrySendOptions {
+    source?: SentryLogSource;
+    warnIfUnavailable?: boolean;
+}
+export interface SentryClientLike {
+    getOptions?: () => {
+        dsn?: unknown;
+        environment?: unknown;
+        release?: unknown;
+    };
+}
+export interface SentryModuleLike {
+    init: (options: Record<string, unknown>) => unknown;
+    getClient: () => SentryClientLike | undefined;
+    captureException: (error: unknown) => unknown;
+    flush: (timeout?: number) => PromiseLike<boolean>;
+    withScope: (callback: (scope: Scope) => void) => void;
+    logger: {
+        debug: (message: string, attributes?: Record<string, unknown>) => void;
+        info: (message: string, attributes?: Record<string, unknown>) => void;
+        warn: (message: string, attributes?: Record<string, unknown>) => void;
+        error: (message: string, attributes?: Record<string, unknown>) => void;
+        fatal: (message: string, attributes?: Record<string, unknown>) => void;
+    };
+}
+export interface SentryTestHooks {
+    module?: SentryModuleLike;
+}
+export interface SentrySender {
+    readonly enabled: boolean;
+    readonly ready: boolean;
+    readonly mode: ConnectorMode;
+    readonly status: 'enabled' | 'missing';
+    shouldAutoForwardServerLogs: () => boolean;
+    send: (record: LogRecord, options?: SentrySendOptions) => void;
+    flush: () => Promise<void>;
+}

package/dist/types/core/config.d.ts

@@ -0,0 +1,152 @@
+import type { ConnectorMode } from '../connectors/mode';
+import type { BlypDestination, DatabaseLoggerConfig, ResolvedDatabaseLoggerConfig } from '../database';
+export type { ConnectorMode } from '../connectors/mode';
+export type { BlypDestination, DatabaseAdapterConfig, DatabaseAdapterKind, DatabaseDeliveryConfig, DatabaseDialect, DatabaseLoggerConfig, DatabaseRetryConfig, DrizzleDatabaseAdapterConfig, PrismaDatabaseAdapterConfig, ResolvedDatabaseDeliveryConfig, ResolvedDatabaseLoggerConfig, ResolvedDatabaseRetryConfig, } from '../database';
+export interface LogRotationConfig {
+    enabled?: boolean;
+    maxSizeBytes?: number;
+    maxArchives?: number;
+    compress?: boolean;
+}
+export interface LogFileConfig {
+    enabled?: boolean;
+    dir?: string;
+    archiveDir?: string;
+    format?: 'ndjson';
+    rotation?: LogRotationConfig;
+}
+export interface ClientLoggingConfig {
+    enabled?: boolean;
+    path?: string;
+}
+export interface PostHogConnectorConfig {
+    enabled?: boolean;
+    mode?: ConnectorMode;
+    projectKey?: string;
+    host?: string;
+    serviceName?: string;
+    errorTracking?: PostHogErrorTrackingConfig;
+}
+export interface BetterStackConnectorConfig {
+    enabled?: boolean;
+    mode?: ConnectorMode;
+    sourceToken?: string;
+    ingestingHost?: string;
+    serviceName?: string;
+    errorTracking?: BetterStackErrorTrackingConfig;
+}
+export interface BetterStackErrorTrackingConfig {
+    enabled?: boolean;
+    dsn?: string;
+    tracesSampleRate?: number;
+    environment?: string;
+    release?: string;
+}
+export interface PostHogErrorTrackingConfig {
+    enabled?: boolean;
+    mode?: ConnectorMode;
+    enableExceptionAutocapture?: boolean;
+}
+export interface ResolvedPostHogErrorTrackingConfig {
+    enabled: boolean;
+    mode: ConnectorMode;
+    enableExceptionAutocapture: boolean;
+    ready: boolean;
+    status: 'enabled' | 'missing';
+}
+export interface ResolvedPostHogConnectorConfig {
+    enabled: boolean;
+    mode: ConnectorMode;
+    projectKey?: string;
+    host: string;
+    serviceName: string;
+    errorTracking: ResolvedPostHogErrorTrackingConfig;
+}
+export interface ResolvedBetterStackConnectorConfig {
+    enabled: boolean;
+    mode: ConnectorMode;
+    sourceToken?: string;
+    ingestingHost?: string;
+    serviceName: string;
+    errorTracking: ResolvedBetterStackErrorTrackingConfig;
+    ready: boolean;
+    status: 'enabled' | 'missing';
+}
+export interface ResolvedBetterStackErrorTrackingConfig {
+    enabled: boolean;
+    dsn?: string;
+    tracesSampleRate: number;
+    environment?: string;
+    release?: string;
+    ready: boolean;
+    status: 'enabled' | 'missing';
+}
+export interface SentryConnectorConfig {
+    enabled?: boolean;
+    mode?: ConnectorMode;
+    dsn?: string;
+    environment?: string;
+    release?: string;
+}
+export interface ResolvedSentryConnectorConfig {
+    enabled: boolean;
+    mode: ConnectorMode;
+    dsn?: string;
+    environment?: string;
+    release?: string;
+    ready: boolean;
+    status: 'enabled' | 'missing';
+}
+export interface OTLPConnectorConfig {
+    name: string;
+    enabled?: boolean;
+    mode?: ConnectorMode;
+    endpoint?: string;
+    headers?: Record<string, string>;
+    auth?: string;
+    serviceName?: string;
+}
+export interface ResolvedOTLPConnectorConfig {
+    name: string;
+    enabled: boolean;
+    mode: ConnectorMode;
+    endpoint?: string;
+    headers: Record<string, string>;
+    auth?: string;
+    serviceName: string;
+    ready: boolean;
+    status: 'enabled' | 'missing';
+}
+export interface BlypConnectorsConfig {
+    betterstack?: BetterStackConnectorConfig;
+    posthog?: PostHogConnectorConfig;
+    sentry?: SentryConnectorConfig;
+    otlp?: OTLPConnectorConfig[];
+}
+export interface BlypConfig {
+    pretty: boolean;
+    level: string;
+    destination?: BlypDestination;
+    logDir?: string;
+    file?: LogFileConfig;
+    database?: DatabaseLoggerConfig;
+    clientLogging?: ClientLoggingConfig;
+    connectors?: BlypConnectorsConfig;
+}
+export interface ResolvedBlypConnectorsConfig {
+    betterstack: ResolvedBetterStackConnectorConfig;
+    posthog: ResolvedPostHogConnectorConfig;
+    sentry: ResolvedSentryConnectorConfig;
+    otlp: ResolvedOTLPConnectorConfig[];
+}
+export interface ResolvedBlypConfig extends BlypConfig {
+    destination: BlypDestination;
+    file: Required<LogFileConfig>;
+    database?: ResolvedDatabaseLoggerConfig;
+    clientLogging: Required<ClientLoggingConfig>;
+    connectors: ResolvedBlypConnectorsConfig;
+}
+export interface ConfigFileMatch {
+    path: string;
+    type: 'json' | 'jiti';
+}

package/dist/types/core/errors.d.ts

@@ -0,0 +1,16 @@
+import type { ErrorLogLevel, ErrorLoggerLike } from '../shared/errors';
+export interface CreateErrorInput {
+    status?: number;
+    message?: string;
+    code?: string | number;
+    why?: string;
+    fix?: string;
+    link?: string;
+    details?: Record<string, unknown>;
+    cause?: unknown;
+    logger?: ErrorLoggerLike;
+    logLevel?: ErrorLogLevel;
+    skipLogging?: boolean;
+}
+export interface CreateErrorOverrides extends Omit<CreateErrorInput, 'status'> {
+}

package/dist/types/core/file-logger.d.ts

@@ -0,0 +1,29 @@
+export interface LogRecord {
+    timestamp: string;
+    level: string;
+    message: string;
+    caller?: string;
+    data?: unknown;
+    bindings?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface StreamState {
+    activePath: string;
+    archivePrefix: string;
+    bytes: number;
+    queue: string[];
+    processing: boolean;
+}
+export interface FileLoggerDependencies {
+    gzip?: (input: Buffer) => Buffer;
+    warn?: (message: string, error?: unknown) => void;
+}
+export interface ResolvedFileLoggerConfig {
+    enabled: boolean;
+    dir: string;
+    archiveDir: string;
+    rotationEnabled: boolean;
+    maxSizeBytes: number;
+    maxArchives: number;
+    compress: boolean;
+}

package/dist/types/core/helpers.d.ts

@@ -0,0 +1,8 @@
+import type { BlypErrorLike } from '../shared/errors';
+export interface ResolveCtx {
+    set?: {
+        status?: number | string;
+    };
+    error?: Pick<BlypErrorLike, 'status' | 'statusCode' | 'code'>;
+    code?: string;
+}

package/dist/types/core/index.d.ts

@@ -0,0 +1,8 @@
+export * from './config';
+export * from './logger';
+export * from './structured-log';
+export * from './file-logger';
+export * from './log-reader';
+export * from './log-record';
+export * from './errors';
+export * from './helpers';

package/dist/types/core/log-reader.d.ts

@@ -0,0 +1,4 @@
+export interface ReadLogFileOptions {
+    format?: 'pretty' | 'json';
+    limit?: number;
+}

package/dist/types/core/log-record.d.ts

@@ -0,0 +1 @@
+export type LogMethodName = 'success' | 'critical' | 'warning' | 'info' | 'debug' | 'error' | 'warn' | 'table';

package/dist/types/core/logger.d.ts

@@ -0,0 +1,40 @@
+import type { BetterStackSender } from '../connectors/betterstack';
+import type { PostHogSender } from '../connectors/posthog';
+import type { SentrySender } from '../connectors/sentry';
+import type { OTLPRegistry } from '../connectors/otlp';
+import type { BlypPrimarySink } from '../../core/primary-sink';
+import type { StructuredLog, StructuredLogPayload } from './structured-log';
+export interface BlypLogger {
+    success: (message: unknown, ...args: unknown[]) => void;
+    critical: (message: unknown, ...args: unknown[]) => void;
+    warning: (message: unknown, ...args: unknown[]) => void;
+    info: (message: unknown, ...args: unknown[]) => void;
+    debug: (message: unknown, ...args: unknown[]) => void;
+    error: (message: unknown, ...args: unknown[]) => void;
+    warn: (message: unknown, ...args: unknown[]) => void;
+    table: (message: string, data?: unknown) => void;
+    flush: () => Promise<void>;
+    shutdown: () => Promise<void>;
+    createStructuredLog: (groupId: string, initial?: Record<string, unknown>) => StructuredLog;
+    child: (bindings: Record<string, unknown>) => BlypLogger;
+}
+export type InternalLoggerSource = 'root' | 'request-scoped' | 'structured-flush';
+export interface StructuredLogFactoryOptions {
+    initialFields?: Record<string, unknown>;
+    resolveDefaultFields?: () => Record<string, unknown>;
+    onCreate?: () => void;
+    onEmit?: (payload: StructuredLogPayload) => void;
+}
+export interface LoggerFactoryHandle {
+    bindings: Record<string, unknown>;
+    betterstack: BetterStackSender;
+    posthog: PostHogSender;
+    sentry: SentrySender;
+    otlp: OTLPRegistry;
+    sink: BlypPrimarySink;
+    create: (source: InternalLoggerSource, bindings?: Record<string, unknown>) => BlypLogger;
+    writeStructured: (payload: StructuredLogPayload, message: string, source?: InternalLoggerSource) => void;
+}
+export type InternalBlypLogger = BlypLogger & {
+    [k: symbol]: LoggerFactoryHandle;
+};

package/dist/types/core/structured-log.d.ts

@@ -0,0 +1,57 @@
+export type StructuredLogLevel = 'debug' | 'info' | 'warn' | 'warning' | 'error' | 'success' | 'critical' | 'table';
+export interface StructuredLogError {
+    message: string;
+    code?: string | number;
+    type?: string;
+    stack?: string;
+    why?: string;
+    fix?: string;
+    link?: string;
+    details?: Record<string, unknown>;
+    cause?: unknown;
+}
+export interface StructuredLogEvent {
+    level: StructuredLogLevel;
+    message: string;
+    timestamp: string;
+    data?: unknown;
+}
+export type StructuredLogPayload<TFields extends Record<string, unknown> = Record<string, unknown>> = TFields & {
+    groupId: string;
+    timestamp: string;
+    level: StructuredLogLevel;
+    method?: string;
+    path?: string;
+    status?: number;
+    duration?: number;
+    events?: StructuredLogEvent[];
+    error?: StructuredLogError;
+};
+export interface StructuredLogEmitOptions {
+    response?: Response | {
+        status: number;
+    };
+    status?: number;
+    error?: unknown;
+    level?: StructuredLogLevel;
+    message?: string;
+}
+export interface StructuredLog<TFields extends Record<string, unknown> = Record<string, unknown>> {
+    set<TNextFields extends Record<string, unknown>>(fields: TNextFields): StructuredLog<TFields & TNextFields>;
+    debug(message: unknown, ...args: unknown[]): StructuredLog<TFields>;
+    info(message: unknown, ...args: unknown[]): StructuredLog<TFields>;
+    warn(message: unknown, ...args: unknown[]): StructuredLog<TFields>;
+    warning(message: unknown, ...args: unknown[]): StructuredLog<TFields>;
+    error(message: unknown, ...args: unknown[]): StructuredLog<TFields>;
+    success(message: unknown, ...args: unknown[]): StructuredLog<TFields>;
+    critical(message: unknown, ...args: unknown[]): StructuredLog<TFields>;
+    table(message: string, data?: unknown): StructuredLog<TFields>;
+    emit(options?: StructuredLogEmitOptions): StructuredLogPayload<TFields>;
+}
+export interface CreateStructuredLogOptions {
+    initialFields?: Record<string, unknown>;
+    resolveDefaultFields?: () => Record<string, unknown>;
+    write(payload: StructuredLogPayload<Record<string, unknown>>, message: string): void;
+    onCreate?: () => void;
+    onEmit?: (payload: StructuredLogPayload<Record<string, unknown>>) => void;
+}

package/dist/types/database.d.ts

@@ -0,0 +1,73 @@
+import type { LogRecord } from './core/file-logger';
+export type BlypDestination = 'file' | 'database';
+export type DatabaseDialect = 'postgres' | 'mysql';
+export type DatabaseAdapterKind = 'prisma' | 'drizzle';
+export interface DatabaseRetryConfig {
+    maxRetries?: number;
+    backoffMs?: number;
+}
+export interface DatabaseDeliveryConfig {
+    strategy?: 'immediate' | 'batch';
+    batchSize?: number;
+    flushIntervalMs?: number;
+    maxQueueSize?: number;
+    overflowStrategy?: 'drop-oldest' | 'drop-new';
+    flushTimeoutMs?: number;
+    retry?: DatabaseRetryConfig;
+}
+export interface ResolvedDatabaseRetryConfig {
+    maxRetries: number;
+    backoffMs: number;
+}
+export interface ResolvedDatabaseDeliveryConfig {
+    strategy: 'immediate' | 'batch';
+    batchSize: number;
+    flushIntervalMs: number;
+    maxQueueSize: number;
+    overflowStrategy: 'drop-oldest' | 'drop-new';
+    flushTimeoutMs: number;
+    retry: ResolvedDatabaseRetryConfig;
+}
+export interface PrismaDatabaseAdapterConfig {
+    type: 'prisma';
+    client: unknown;
+    model?: string;
+}
+export interface DrizzleDatabaseAdapterConfig {
+    type: 'drizzle';
+    db: unknown;
+    table: unknown;
+}
+export type DatabaseAdapterConfig = PrismaDatabaseAdapterConfig | DrizzleDatabaseAdapterConfig;
+export interface DatabaseLoggerConfig {
+    dialect?: DatabaseDialect;
+    adapter?: DatabaseAdapterConfig;
+    delivery?: DatabaseDeliveryConfig;
+}
+export interface ResolvedDatabaseLoggerConfig {
+    dialect?: DatabaseDialect;
+    adapter?: DatabaseAdapterConfig;
+    delivery: ResolvedDatabaseDeliveryConfig;
+    ready: boolean;
+    status: 'enabled' | 'missing';
+}
+export interface DatabaseLogRow {
+    id: string;
+    timestamp: Date;
+    level: string;
+    message: string;
+    caller: string | null;
+    type: string | null;
+    groupId: string | null;
+    method: string | null;
+    path: string | null;
+    status: number | null;
+    duration: number | null;
+    hasError: boolean;
+    data: unknown | null;
+    bindings: Record<string, unknown> | null;
+    error: Record<string, unknown> | null;
+    events: unknown[] | null;
+    record: LogRecord;
+    createdAt: Date;
+}

package/dist/types/frameworks/client.d.ts

@@ -0,0 +1,32 @@
+import type { ClientConnectorRequest, ClientLogBrowserContext, ClientLogDeviceContext, ClientLogEvent, ClientLogLevel, ClientLogPageContext, RemoteDeliveryConfig, RemoteDeliveryDropContext, RemoteDeliveryFailureContext, RemoteDeliveryFailureReason, RemoteDeliveryRetryContext, RemoteDeliverySuccessContext } from '../shared/client-log';
+import type { ErrorLogLevel, ErrorLoggerLike, ParseErrorOptions, ParseableErrorPayload, BlypErrorCode, BlypErrorCodeDefinition, BlypErrorLike } from '../shared/errors';
+export interface ClientLoggerState {
+    readonly pageId: string;
+    readonly sessionId: string;
+    readonly bindings: Record<string, unknown>;
+    readonly delivery?: {
+        enqueue: (event: ClientLogEvent) => void;
+    };
+}
+export interface ClientLoggerConfig {
+    endpoint?: string;
+    headers?: Record<string, string>;
+    credentials?: RequestCredentials;
+    localConsole?: boolean;
+    remoteSync?: boolean;
+    connector?: ClientConnectorRequest;
+    metadata?: Record<string, unknown> | (() => Record<string, unknown>);
+    delivery?: RemoteDeliveryConfig;
+}
+export interface ClientLogger {
+    success: (message: unknown, ...args: unknown[]) => void;
+    critical: (message: unknown, ...args: unknown[]) => void;
+    warning: (message: unknown, ...args: unknown[]) => void;
+    info: (message: unknown, ...args: unknown[]) => void;
+    debug: (message: unknown, ...args: unknown[]) => void;
+    error: (message: unknown, ...args: unknown[]) => void;
+    warn: (message: unknown, ...args: unknown[]) => void;
+    table: (message: string, data?: unknown) => void;
+    child: (bindings: Record<string, unknown>) => ClientLogger;
+}
+export type { ClientLogBrowserContext, ClientConnectorRequest, ClientLogDeviceContext, ClientLogEvent, ClientLogLevel, ClientLogPageContext, RemoteDeliveryConfig, RemoteDeliveryDropContext, RemoteDeliveryFailureContext, RemoteDeliveryFailureReason, RemoteDeliveryRetryContext, RemoteDeliverySuccessContext, ErrorLogLevel, ErrorLoggerLike, ParseErrorOptions, ParseableErrorPayload, BlypErrorCode, BlypErrorCodeDefinition, BlypErrorLike, };