@arcote.tech/arc 0.1.12 → 0.3.0

package/dist/query/query-definition.d.ts

@@ -1,8 +0,0 @@
-export type QueryDefinition<TResult = any> = {
-    readonly contextElementName: string;
-    readonly queryAlias: string;
-    readonly parameters: any[];
-    readonly restrictions?: any;
-};
-export type QueryDefinitionResult<QD extends QueryDefinition> = QD extends QueryDefinition<infer T> ? T : unknown;
-//# sourceMappingURL=query-definition.d.ts.map

package/dist/route/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./route";
-//# sourceMappingURL=index.d.ts.map

package/dist/route/route.d.ts

@@ -1,35 +0,0 @@
-import type { ArcCommandContext } from "../context";
-import { ArcContextElement, type ArcContextElementAny } from "../context/element";
-export type ArcRouteHandler<ContextElements extends ArcContextElementAny[]> = (ctx: ArcCommandContext<ContextElements>, request: Request, params: Record<string, string>, url: URL) => Promise<Response> | Response;
-export type ArcRouteHandlers<ContextElements extends ArcContextElementAny[]> = {
-    [Method in "GET" | "POST" | "PUT" | "DELETE" | "PATCH"]?: ArcRouteHandler<ContextElements>;
-};
-export declare class ArcRoute<Name extends string, const Elements extends ArcContextElementAny[]> extends ArcContextElement<null, Name> {
-    readonly name: Name;
-    private _description?;
-    private _path?;
-    private _elements?;
-    private _handlers?;
-    private _isPublic;
-    constructor(name: Name);
-    use<const E extends ArcContextElementAny[]>(elements: E): ArcRoute<Name, E>;
-    description(description: string): ArcRoute<Name, Elements>;
-    path(path: string): ArcRoute<Name, Elements>;
-    public(): ArcRoute<Name, Elements>;
-    get isPublic(): boolean;
-    get routePath(): string;
-    handle(handlers: ArcRouteHandlers<Elements>): ArcRoute<Name, Elements>;
-    getHandler(method: string): ArcRouteHandler<Elements> | undefined;
-    matchesPath(pathname: string): {
-        matches: boolean;
-        params: Record<string, string>;
-    };
-    matchesRoutePath(pathname: string): {
-        matches: boolean;
-        isPublic: boolean;
-        params?: Record<string, string>;
-    };
-    private clone;
-}
-export declare function route<Name extends string>(name: Name): ArcRoute<Name, any[]>;
-//# sourceMappingURL=route.d.ts.map

package/dist/rtc/client.d.ts

@@ -1,3 +0,0 @@
-import type { RealTimeCommunicationAdapterFactory } from "./rtc";
-export declare const rtcClientFactory: (token: string) => RealTimeCommunicationAdapterFactory;
-//# sourceMappingURL=client.d.ts.map

package/dist/rtc/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./client";
-export * from "./messages";
-export * from "./rtc";
-//# sourceMappingURL=index.d.ts.map

package/dist/rtc/messages.d.ts

@@ -1,20 +0,0 @@
-import type { DataStorageChanges } from "../data-storage/data-storage.abstract";
-export type MessageClientToHost = {
-    type: "sync";
-    lastDate: string | null;
-} | {
-    type: "changes-executed";
-    changes: DataStorageChanges[];
-};
-export type MessageHostToClient = {
-    type: "sync-result";
-    store: string;
-    items: any[];
-} | {
-    type: "state-changes";
-    changes: DataStorageChanges[];
-} | {
-    type: "sync-done";
-    date: string;
-};
-//# sourceMappingURL=messages.d.ts.map

package/dist/rtc/rtc.d.ts

@@ -1,11 +0,0 @@
-import type { MasterDataStorage } from "../data-storage";
-import type { DataStorageChanges } from "../data-storage/data-storage.abstract";
-export interface RealTimeCommunicationAdapter {
-    commitChanges(changes: DataStorageChanges[]): void;
-    sync(progressCallback: ({ store, size }: {
-        store: string;
-        size: number;
-    }) => void): Promise<void>;
-}
-export type RealTimeCommunicationAdapterFactory = (storage: MasterDataStorage) => RealTimeCommunicationAdapter;
-//# sourceMappingURL=rtc.d.ts.map

package/dist/server/query-handler.d.ts

@@ -1,43 +0,0 @@
-import type { ArcContextAny } from "../context";
-import type { AuthContext } from "../context/element";
-import type { DataStorage } from "../data-storage";
-import { QueryDefinition } from "../strategies";
-export declare class QueryHandler<C extends ArcContextAny> {
-    private model;
-    constructor(context: C, dataStorage: DataStorage, catchErrorCallback?: (error: any) => void);
-    /**
-     * Handle HTTP query requests
-     */
-    handleQuery(queryDefinition: QueryDefinition, authContext: AuthContext): Promise<any>;
-    /**
-     * Handle HTTP query requests with streaming for real-time updates
-     */
-    handleQueryWithStream(queryDefinition: QueryDefinition, authContext: AuthContext, streamCallback: (result: any) => void): Promise<any>;
-    /**
-     * Handle query sync requests for cache strategy
-     */
-    handleQuerySync(queryDefinition: QueryDefinition, authContext: AuthContext, syncData: {
-        id: string;
-        version?: string;
-    }[]): Promise<{
-        updates: any[];
-    }>;
-}
-/**
- * Helper function to create HTTP handlers for different frameworks
- */
-export declare function createHttpQueryHandlers<C extends ArcContextAny>(context: C, dataStorage: DataStorage, catchErrorCallback?: (error: any) => void): {
-    /**
-     * Handle POST /query
-     */
-    handleQueryRequest: (req: Request) => Promise<Response>;
-    /**
-     * Handle POST /query-stream/:streamId
-     */
-    handleQueryStreamRequest: (req: Request, streamId: string) => Promise<Response>;
-    /**
-     * Handle POST /query-sync
-     */
-    handleQuerySyncRequest: (req: Request) => Promise<Response>;
-};
-//# sourceMappingURL=query-handler.d.ts.map

package/dist/state/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./state";
-//# sourceMappingURL=index.d.ts.map

package/dist/state/query-builder.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=query-builder.d.ts.map

package/dist/state/query.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=query.d.ts.map

package/dist/state/state.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=state.d.ts.map

package/dist/strategies/cache-strategy.d.ts

@@ -1,20 +0,0 @@
-import type { ArcContextAny } from "../context";
-import type { AuthContext } from "../context/element";
-import type { DataStorage } from "../data-storage";
-import type { QueryDefinition } from "../query/query-definition";
-import type { CommandDefinition } from "../command/command-definition";
-import type { ModelStrategy } from "./model-strategy";
-export declare class CacheStrategy<C extends ArcContextAny> implements ModelStrategy {
-    private readonly dataStorage;
-    private dataStorageStrategy;
-    private leaderStrategy;
-    constructor(context: C, dataStorage: DataStorage, apiBaseUrl: string);
-    setAuthToken(token: string | null): void;
-    query<TResult = any>(queryDefinition: QueryDefinition<TResult>, authContext: AuthContext, callback?: (result: TResult) => void): Promise<TResult>;
-    command(commandDefinition: CommandDefinition, authContext: AuthContext): Promise<any>;
-    private extractSyncData;
-    private syncWithLeader;
-    private updateCache;
-    private establishLiveUpdates;
-}
-//# sourceMappingURL=cache-strategy.d.ts.map

package/dist/strategies/datastorage-strategy.d.ts

@@ -1,15 +0,0 @@
-import type { ArcContextAny } from "../context";
-import type { AuthContext } from "../context/element";
-import type { DataStorage } from "../data-storage";
-import type { QueryDefinition } from "../query/query-definition";
-import type { CommandDefinition } from "../command/command-definition";
-import type { ModelStrategy } from "./model-strategy";
-export declare class DataStorageStrategy<C extends ArcContextAny> implements ModelStrategy {
-    private readonly context;
-    readonly dataStorage: DataStorage;
-    private readonly catchErrorCallback?;
-    constructor(context: C, dataStorage: DataStorage, catchErrorCallback?: ((error: any) => void) | undefined);
-    query<TResult = any>(queryDefinition: QueryDefinition<TResult>, authContext: AuthContext, callback?: (result: TResult) => void): Promise<TResult>;
-    command(commandDefinition: CommandDefinition, authContext: AuthContext): Promise<any>;
-}
-//# sourceMappingURL=datastorage-strategy.d.ts.map

package/dist/strategies/index.d.ts

@@ -1,7 +0,0 @@
-export * from "./model-strategy";
-export * from "./datastorage-strategy";
-export * from "./leader-strategy";
-export * from "./cache-strategy";
-export type { QueryDefinition } from "../query/query-definition";
-export type { CommandDefinition } from "../command/command-definition";
-//# sourceMappingURL=index.d.ts.map

package/dist/strategies/leader-strategy.d.ts

@@ -1,16 +0,0 @@
-import type { AuthContext } from "../context/element";
-import type { QueryDefinition } from "../query/query-definition";
-import type { CommandDefinition } from "../command/command-definition";
-import type { ModelStrategy } from "./model-strategy";
-export declare class LeaderStrategy implements ModelStrategy {
-    private readonly apiBaseUrl;
-    private token;
-    constructor(apiBaseUrl: string);
-    setAuthToken(token: string | null): void;
-    query<TResult = any>(queryDefinition: QueryDefinition<TResult>, authContext: AuthContext, callback?: (result: TResult) => void): Promise<TResult>;
-    private queryWithStream;
-    private readStream;
-    command(commandDefinition: CommandDefinition, authContext: AuthContext): Promise<any>;
-    private getAuthHeaders;
-}
-//# sourceMappingURL=leader-strategy.d.ts.map

package/dist/strategies/model-strategy.d.ts

@@ -1,9 +0,0 @@
-import type { AuthContext } from "../context/element";
-import type { QueryDefinition } from "../query/query-definition";
-import type { CommandDefinition } from "../command/command-definition";
-export interface ModelStrategy {
-    query<TResult = any>(queryDefinition: QueryDefinition<TResult>, authContext: AuthContext, callback?: (result: TResult) => void): Promise<TResult>;
-    command(commandDefinition: CommandDefinition, authContext: AuthContext): Promise<any>;
-    setAuthToken?(token: string | null): void;
-}
-//# sourceMappingURL=model-strategy.d.ts.map

package/dist/strategies/query-strategy.d.ts

@@ -1,20 +0,0 @@
-import type { AuthContext } from "../context/element";
-export interface QueryDefinition {
-    contextElementName: string;
-    queryAlias: string;
-    parameters: any[];
-    restrictions?: any;
-}
-export interface CommandDefinition {
-    contextElementName: string;
-    parameters: any;
-}
-export interface ModelStrategy {
-    query(queryDefinition: QueryDefinition, authContext: AuthContext, callback?: (result: any) => void): Promise<any>;
-    command(commandDefinition: CommandDefinition, authContext: AuthContext): Promise<any>;
-    setAuthToken?(token: string | null): void;
-}
-export interface QueryStrategy extends ModelStrategy {
-    execute(queryDefinition: QueryDefinition, authContext: AuthContext, callback?: (result: any) => void): Promise<any>;
-}
-//# sourceMappingURL=query-strategy.d.ts.map

package/dist/telemetry/context.d.ts

@@ -1,65 +0,0 @@
-import type { Span } from '@opentelemetry/api';
-import type { AuthContext } from '../context/element';
-import { ArcLogger } from './logger';
-/**
- * Extended context that includes telemetry capabilities
- */
-export interface ArcTelemetryContext {
-    /**
-     * Log a message with automatic trace context
-     */
-    log: ArcLogger;
-    /**
-     * Create a child span for a specific operation
-     */
-    startSpan(name: string, attributes?: Record<string, string | number | boolean>): Span;
-    /**
-     * Execute a function within a new span
-     */
-    withSpan<T>(name: string, fn: (span: Span) => Promise<T> | T, attributes?: Record<string, string | number | boolean>): Promise<T>;
-    /**
-     * Add attributes to the current span
-     */
-    addSpanAttributes(attributes: Record<string, string | number | boolean>): void;
-    /**
-     * Add an event to the current span
-     */
-    addSpanEvent(name: string, attributes?: Record<string, string | number | boolean>): void;
-    /**
-     * Record an exception in the current span
-     */
-    recordException(error: Error | string): void;
-    /**
-     * Get the current trace ID
-     */
-    getTraceId(): string | undefined;
-    /**
-     * Get the current span ID
-     */
-    getSpanId(): string | undefined;
-}
-/**
- * Create telemetry context for command/event handlers
- */
-export declare function createTelemetryContext(authContext: AuthContext, operationType: 'command' | 'event' | 'listener' | 'view', operationName: string): ArcTelemetryContext;
-/**
- * Extract trace context from headers (for HTTP requests)
- */
-export declare function extractTraceContext(headers: Record<string, string | string[] | undefined>): import("@opentelemetry/api").Context;
-/**
- * Inject trace context into headers (for outgoing HTTP requests)
- */
-export declare function injectTraceContext(headers?: Record<string, string>): Record<string, string>;
-/**
- * Run a function with extracted trace context
- */
-export declare function withExtractedContext<T>(headers: Record<string, string | string[] | undefined>, fn: () => T): T;
-/**
- * Get telemetry information from current context
- */
-export declare function getCurrentTelemetryInfo(): {
-    traceId: string | undefined;
-    spanId: string | undefined;
-    isRecording: boolean;
-};
-//# sourceMappingURL=context.d.ts.map

package/dist/telemetry/index.d.ts

@@ -1,47 +0,0 @@
-export type { TelemetryProvider, TelemetryContext, Logger, SpanOptions, DatabaseTelemetry } from './interfaces';
-export { NoOpLogger, NoOpTelemetryContext, NoOpTelemetryProvider, NoOpDatabaseTelemetry, noOpTelemetryProvider, noOpDatabaseTelemetry, } from './no-op';
-export declare const initializeTelemetry: (...args: any[]) => never;
-export declare const getTelemetry: () => null;
-export declare const startSpan: (...args: any[]) => never;
-export declare const withSpan: (...args: any[]) => never;
-export declare const ArcTelemetry: {
-    new (): {};
-};
-export declare const initializeLogger: (...args: any[]) => never;
-export declare const getLogger: () => never;
-export declare const ArcLogger: {
-    new (): {};
-};
-export declare const createTelemetryContext: (...args: any[]) => never;
-export declare const extractTraceContext: (...args: any[]) => never;
-export declare const injectTraceContext: (...args: any[]) => never;
-export declare const withExtractedContext: (...args: any[]) => never;
-export declare const getCurrentTelemetryInfo: () => {
-    traceId: undefined;
-    spanId: undefined;
-    isRecording: boolean;
-};
-export type TelemetryConfig = any;
-export type LogContext = Record<string, any>;
-export type LogEntry = any;
-export type ArcTelemetryContext = any;
-export declare const SpanKind: {
-    readonly INTERNAL: "internal";
-    readonly SERVER: "server";
-    readonly CLIENT: "client";
-    readonly PRODUCER: "producer";
-    readonly CONSUMER: "consumer";
-};
-export declare const SpanStatusCode: {
-    readonly UNSET: 0;
-    readonly OK: 1;
-    readonly ERROR: 2;
-};
-export declare const LogLevel: {
-    readonly ERROR: "error";
-    readonly WARN: "warn";
-    readonly INFO: "info";
-    readonly DEBUG: "debug";
-    readonly TRACE: "trace";
-};
-//# sourceMappingURL=index.d.ts.map

package/dist/telemetry/interfaces.d.ts

@@ -1,84 +0,0 @@
-import type { AuthContext } from '../context/element';
-/**
- * Environment-agnostic telemetry context that handlers receive
- * Automatically correlates logs with trace IDs
- */
-export interface TelemetryContext {
-    /**
-     * Logging methods that auto-correlate with trace ID
-     */
-    log: {
-        info(message: string, context?: Record<string, any>): void;
-        error(message: string, context?: Record<string, any>, error?: Error): void;
-        debug(message: string, context?: Record<string, any>): void;
-        warn(message: string, context?: Record<string, any>): void;
-        command(name: string, message: string, context?: Record<string, any>): void;
-        event(type: string, message: string, context?: Record<string, any>): void;
-        database(operation: string, message: string, context?: Record<string, any>): void;
-        http(method: string, path: string, statusCode: number, duration: number, context?: Record<string, any>): void;
-    };
-    /**
-     * Span management (automatically correlates logs with traces)
-     */
-    startSpan(name: string, attributes?: Record<string, string | number | boolean>): void;
-    addAttributes(attributes: Record<string, string | number | boolean>): void;
-    addEvent(name: string, attributes?: Record<string, string | number | boolean>): void;
-    recordException(error: Error | string): void;
-    /**
-     * Trace correlation info
-     */
-    getTraceId(): string | undefined;
-    getSpanId(): string | undefined;
-}
-/**
- * Span options for creating new spans
- */
-export interface SpanOptions {
-    kind?: 'client' | 'server' | 'internal' | 'producer' | 'consumer';
-    attributes?: Record<string, string | number | boolean>;
-}
-/**
- * Main telemetry provider interface that environments must implement
- */
-export interface TelemetryProvider {
-    /**
-     * Create a logger instance
-     */
-    createLogger(name: string): Logger;
-    /**
-     * Execute function within a span context
-     */
-    withSpan<T>(name: string, fn: (context: TelemetryContext) => Promise<T> | T, options?: SpanOptions): Promise<T>;
-    /**
-     * Create telemetry context for command/route handlers
-     */
-    createTelemetryContext(authContext: AuthContext, operationType: 'command' | 'event' | 'listener' | 'view' | 'route', operationName: string): TelemetryContext;
-    /**
-     * Check if telemetry is enabled
-     */
-    isEnabled(): boolean;
-}
-/**
- * Basic logger interface
- */
-export interface Logger {
-    info(message: string, context?: Record<string, any>): void;
-    error(message: string, context?: Record<string, any>, error?: Error): void;
-    debug(message: string, context?: Record<string, any>): void;
-    warn(message: string, context?: Record<string, any>): void;
-    command(name: string, message: string, context?: Record<string, any>): void;
-    event(type: string, message: string, context?: Record<string, any>): void;
-    database(operation: string, message: string, context?: Record<string, any>): void;
-    http(method: string, path: string, statusCode: number, duration: number, context?: Record<string, any>): void;
-    child(context: Record<string, any>): Logger;
-}
-/**
- * Database telemetry interface for adapters
- */
-export interface DatabaseTelemetry {
-    /**
-     * Execute a database operation with telemetry
-     */
-    withDatabaseOperation<T>(operation: string, sql: string, params: any[] | undefined, tableName: string | undefined, fn: () => Promise<T>): Promise<T>;
-}
-//# sourceMappingURL=interfaces.d.ts.map

package/dist/telemetry/logger.d.ts

@@ -1,67 +0,0 @@
-export declare enum LogLevel {
-    ERROR = "error",
-    WARN = "warn",
-    INFO = "info",
-    DEBUG = "debug",
-    TRACE = "trace"
-}
-interface LogContext {
-    [key: string]: any;
-}
-interface LogEntry {
-    level: LogLevel;
-    message: string;
-    context?: LogContext;
-    timestamp?: string;
-    traceId?: string;
-    spanId?: string;
-    userId?: string;
-    requestId?: string;
-    command?: string;
-    event?: string;
-    error?: Error;
-}
-declare class ArcLogger {
-    private serviceName;
-    constructor(serviceName?: string);
-    private createLogEntry;
-    private formatForConsole;
-    private output;
-    private getSeverityNumber;
-    error(message: string, context?: LogContext, error?: Error): void;
-    warn(message: string, context?: LogContext): void;
-    info(message: string, context?: LogContext): void;
-    debug(message: string, context?: LogContext): void;
-    trace(message: string, context?: LogContext): void;
-    /**
-     * Log command execution
-     */
-    command(commandName: string, message: string, context?: LogContext): void;
-    /**
-     * Log event processing
-     */
-    event(eventType: string, message: string, context?: LogContext): void;
-    /**
-     * Log database operations
-     */
-    database(operation: string, message: string, context?: LogContext): void;
-    /**
-     * Log HTTP requests
-     */
-    http(method: string, path: string, statusCode: number, duration: number, context?: LogContext): void;
-    /**
-     * Create a child logger with additional context
-     */
-    child(context: LogContext): ArcLogger;
-}
-/**
- * Initialize global logger
- */
-export declare function initializeLogger(serviceName?: string): ArcLogger;
-/**
- * Get the global logger instance
- */
-export declare function getLogger(): ArcLogger;
-export { ArcLogger };
-export type { LogContext, LogEntry };
-//# sourceMappingURL=logger.d.ts.map

package/dist/telemetry/no-op.d.ts

@@ -1,54 +0,0 @@
-import type { TelemetryProvider, TelemetryContext, Logger, DatabaseTelemetry } from './interfaces';
-/**
- * No-op logger implementation for when telemetry is disabled
- */
-export declare class NoOpLogger implements Logger {
-    info(): void;
-    error(): void;
-    debug(): void;
-    warn(): void;
-    command(): void;
-    event(): void;
-    database(): void;
-    http(): void;
-    child(): Logger;
-}
-/**
- * No-op telemetry context for when telemetry is disabled
- */
-export declare class NoOpTelemetryContext implements TelemetryContext {
-    private logger;
-    log: NoOpLogger;
-    startSpan(): void;
-    addAttributes(): void;
-    addEvent(): void;
-    recordException(): void;
-    getTraceId(): undefined;
-    getSpanId(): undefined;
-}
-/**
- * No-op telemetry provider for when telemetry is disabled
- */
-export declare class NoOpTelemetryProvider implements TelemetryProvider {
-    private logger;
-    private context;
-    createLogger(): Logger;
-    withSpan<T>(name: string, fn: (context: TelemetryContext) => Promise<T> | T): Promise<T>;
-    createTelemetryContext(): TelemetryContext;
-    isEnabled(): boolean;
-}
-/**
- * No-op database telemetry for when telemetry is disabled
- */
-export declare class NoOpDatabaseTelemetry implements DatabaseTelemetry {
-    withDatabaseOperation<T>(operation: string, sql: string, params: any[] | undefined, tableName: string | undefined, fn: () => Promise<T>): Promise<T>;
-}
-/**
- * Default no-op telemetry provider instance
- */
-export declare const noOpTelemetryProvider: NoOpTelemetryProvider;
-/**
- * Default no-op database telemetry instance
- */
-export declare const noOpDatabaseTelemetry: NoOpDatabaseTelemetry;
-//# sourceMappingURL=no-op.d.ts.map

package/dist/telemetry/tracer.d.ts

@@ -1,85 +0,0 @@
-import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
-import type { Span } from "@opentelemetry/api";
-interface TelemetryConfig {
-    serviceName: string;
-    serviceVersion: string;
-    environment: string;
-    otlpEndpoint?: string;
-    enabled?: boolean;
-}
-declare class ArcTelemetry {
-    private sdk?;
-    private tracer;
-    private logger;
-    private config;
-    constructor(config: TelemetryConfig);
-    private initialize;
-    /**
-     * Create a new span for tracing operations
-     */
-    startSpan(name: string, options?: {
-        kind?: SpanKind;
-        attributes?: Record<string, string | number | boolean>;
-        parent?: Span;
-    }): Span;
-    /**
-     * Execute a function within a span context
-     */
-    withSpan<T>(name: string, fn: (span: Span) => Promise<T> | T, options?: {
-        kind?: SpanKind;
-        attributes?: Record<string, string | number | boolean>;
-    }): Promise<T>;
-    /**
-     * Add attributes to the current active span
-     */
-    addSpanAttributes(attributes: Record<string, string | number | boolean>): void;
-    /**
-     * Add an event to the current active span
-     */
-    addSpanEvent(name: string, attributes?: Record<string, string | number | boolean>): void;
-    /**
-     * Record an exception in the current span
-     */
-    recordException(error: Error | string): void;
-    /**
-     * Shutdown telemetry (call on app shutdown)
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Check if telemetry is enabled
-     */
-    get isEnabled(): boolean;
-    /**
-     * Get the current tracer instance
-     */
-    getTracer(): any;
-    /**
-     * Get the current logger instance
-     */
-    getLogger(): any;
-}
-/**
- * Initialize global telemetry
- */
-export declare function initializeTelemetry(config: TelemetryConfig): ArcTelemetry;
-/**
- * Get the global telemetry instance
- */
-export declare function getTelemetry(): ArcTelemetry | null;
-/**
- * Helper function to create a span
- */
-export declare function startSpan(name: string, options?: {
-    kind?: SpanKind;
-    attributes?: Record<string, string | number | boolean>;
-}): Span;
-/**
- * Helper function to execute code within a span
- */
-export declare function withSpan<T>(name: string, fn: (span: Span) => Promise<T> | T, options?: {
-    kind?: SpanKind;
-    attributes?: Record<string, string | number | boolean>;
-}): Promise<T>;
-export { ArcTelemetry, SpanKind, SpanStatusCode };
-export type { TelemetryConfig };
-//# sourceMappingURL=tracer.d.ts.map

package/dist/tests/context/context.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=context.test.d.ts.map

package/dist/tests/pipe.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=pipe.d.ts.map