@gravito/echo 3.0.0 → 3.1.0

package/dist/core/src/http/middleware/SecurityHeaders.d.ts

@@ -0,0 +1,29 @@
+import type { GravitoContext, GravitoMiddleware } from '../types';
+/**
+ * HSTS Configuration
+ * @public
+ */
+export type HstsOptions = {
+    maxAge: number;
+    includeSubDomains?: boolean;
+    preload?: boolean;
+};
+/**
+ * Options for Security Headers middleware
+ * @public
+ */
+export type SecurityHeadersOptions = {
+    contentSecurityPolicy?: string | false | ((c: GravitoContext) => string | false);
+    frameOptions?: string | false;
+    referrerPolicy?: string | false;
+    noSniff?: boolean;
+    hsts?: HstsOptions | false;
+    permissionsPolicy?: string | false;
+    crossOriginOpenerPolicy?: string | false;
+    crossOriginResourcePolicy?: string | false;
+};
+/**
+ * Apply common security headers to responses (Helmet-style).
+ * @public
+ */
+export declare function securityHeaders(options?: SecurityHeadersOptions): GravitoMiddleware;

package/dist/core/src/http/middleware/ThrottleRequests.d.ts

@@ -0,0 +1,18 @@
+import type { GravitoMiddleware } from '../../http/types';
+import type { PlanetCore } from '../../PlanetCore';
+/**
+ * Rate Limiting Middleware using Orbit Cache.
+ * Requires an active CacheService implementation.
+ * @public
+ */
+export declare class ThrottleRequests {
+    private core;
+    private keyCache;
+    constructor(core: PlanetCore);
+    /**
+     * Create the middleware
+     * @param maxAttempts - Max requests allowed
+     * @param decaySeconds - Time window in seconds
+     */
+    handle(maxAttempts?: number, decaySeconds?: number): GravitoMiddleware;
+}

package/dist/core/src/http/types.d.ts

@@ -0,0 +1,355 @@
+/**
+ * @fileoverview Core HTTP Types for Gravito Framework
+ *
+ * These types provide a unified abstraction layer that decouples the framework
+ * from any specific HTTP engine (Photon, Express, custom, etc.).
+ *
+ * @module @gravito/core/http
+ * @since 2.0.0
+ */
+declare global {
+    interface ExecutionContext {
+        waitUntil(promise: Promise<unknown>): void;
+        passThroughOnException(): void;
+    }
+}
+/**
+ * Standard HTTP methods supported by Gravito
+ */
+export type HttpMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';
+/**
+ * HTTP status codes
+ */
+export type StatusCode = number;
+/**
+ * Content-bearing HTTP status codes (excludes 1xx, 204, 304)
+ */
+export type ContentfulStatusCode = Exclude<StatusCode, 100 | 101 | 102 | 103 | 204 | 304>;
+/**
+ * Base context variables available in every request
+ * Orbits can extend this interface via module augmentation
+ *
+ * @example
+ * ```typescript
+ * // Extending variables in your orbit:
+ * declare module '@gravito/core' {
+ *   interface GravitoVariables {
+ *     myService: MyService
+ *   }
+ * }
+ * ```
+ */
+export interface GravitoVariables {
+    /**
+     * The PlanetCore instance
+     * @remarks Always available in PlanetCore-managed contexts
+     */
+    core?: unknown;
+    /**
+     * Logger instance
+     */
+    logger?: unknown;
+    /**
+     * Configuration manager
+     */
+    config?: unknown;
+    /**
+     * Cookie jar for managing response cookies
+     */
+    cookieJar?: unknown;
+    /**
+     * Middleware scope tracking for Orbit isolation
+     * Tracks which Orbit/scope this request belongs to
+     * Used to prevent cross-Orbit middleware contamination
+     * @since 2.3.0
+     */
+    middlewareScope?: string;
+    /** @deprecated Use ctx.route() instead */
+    route?: unknown;
+    [key: string]: unknown;
+}
+/**
+ * Validated request data targets
+ */
+export type ValidationTarget = 'json' | 'query' | 'param' | 'header' | 'form' | 'cookie';
+/**
+ * GravitoRequest - Unified request interface
+ *
+ * Provides a consistent API for accessing request data regardless of
+ * the underlying HTTP engine.
+ *
+ * @example
+ * ```typescript
+ * const userId = ctx.req.param('id')
+ * const search = ctx.req.query('q')
+ * const body = await ctx.req.json<CreateUserDto>()
+ * ```
+ */
+export interface GravitoRequest {
+    /** Full request URL */
+    readonly url: string;
+    /** HTTP method (uppercase) */
+    readonly method: string;
+    /** Request path without query string */
+    readonly path: string;
+    /**
+     * Route pattern (e.g., /users/:id) for the matched route
+     *
+     * This provides the parameterized route pattern instead of the concrete path,
+     * which is critical for preventing high cardinality issues in metrics systems.
+     *
+     * @example
+     * ```typescript
+     * // For request: GET /users/123
+     * ctx.req.path          // => "/users/123"
+     * ctx.req.routePattern  // => "/users/:id"
+     * ```
+     */
+    readonly routePattern?: string;
+    /**
+     * Get a route parameter value
+     * @param name - Parameter name (e.g., 'id' for route '/users/:id')
+     */
+    param(name: string): string | undefined;
+    /**
+     * Get all route parameters
+     */
+    params(): Record<string, string>;
+    /**
+     * Get a query string parameter
+     * @param name - Query parameter name
+     */
+    query(name: string): string | undefined;
+    /**
+     * Get all query parameters
+     */
+    queries(): Record<string, string | string[]>;
+    /**
+     * Get a request header value
+     * @param name - Header name (case-insensitive)
+     */
+    header(name: string): string | undefined;
+    /**
+     * Get all request headers
+     */
+    header(): Record<string, string>;
+    /**
+     * Parse request body as JSON
+     * @throws {Error} If body is not valid JSON
+     */
+    json<T = unknown>(): Promise<T>;
+    /**
+     * Parse request body as text
+     */
+    text(): Promise<string>;
+    /**
+     * Parse request body as FormData
+     */
+    formData(): Promise<FormData>;
+    /**
+     * Parse request body as ArrayBuffer
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * Parse form data (urlencoded or multipart)
+     */
+    parseBody<T = unknown>(): Promise<T>;
+    /**
+     * Get the raw Request object
+     */
+    readonly raw: Request;
+    /**
+     * Get validated data from a specific source
+     * @param target - The validation target
+     * @throws {Error} If validation was not performed for this target
+     */
+    valid<T = unknown>(target: ValidationTarget): T;
+}
+/**
+ * Options for request forwarding (Proxy)
+ */
+export interface ProxyOptions {
+    /** Override or add request headers */
+    headers?: Record<string, string>;
+    /** Whether to keep the original Host header (default: false) */
+    preserveHost?: boolean;
+    /** Whether to add X-Forwarded-* headers (default: true) */
+    addForwardedHeaders?: boolean;
+    /** Path rewriting logic */
+    rewritePath?: (path: string) => string;
+}
+/**
+ * GravitoContext - Unified request context
+ *
+ * This interface encapsulates all HTTP request/response operations,
+ * enabling seamless replacement of the underlying HTTP engine.
+ *
+ * @typeParam V - Context variables type
+ *
+ * @example
+ * ```typescript
+ * // In a controller
+ * async show(ctx: GravitoContext) {
+ *   const id = ctx.req.param('id')
+ *   const user = await User.find(id)
+ *   return ctx.json({ user })
+ * }
+ * ```
+ */
+export interface GravitoContext<V extends GravitoVariables = GravitoVariables> {
+    /** The incoming request */
+    readonly req: GravitoRequest;
+    /**
+     * Send a JSON response
+     * @param data - Data to serialize as JSON
+     * @param status - HTTP status code (default: 200)
+     */
+    json<T>(data: T, status?: ContentfulStatusCode): Response;
+    /**
+     * Send a plain text response
+     * @param text - Text content
+     * @param status - HTTP status code (default: 200)
+     */
+    text(text: string, status?: ContentfulStatusCode): Response;
+    /**
+     * Send an HTML response
+     * @param html - HTML content
+     * @param status - HTTP status code (default: 200)
+     */
+    html(html: string, status?: ContentfulStatusCode): Response;
+    /**
+     * Send a redirect response
+     * @param url - Target URL
+     * @param status - Redirect status code (default: 302)
+     */
+    redirect(url: string, status?: 301 | 302 | 303 | 307 | 308): Response;
+    /**
+     * Create a Response with no body
+     * @param status - HTTP status code
+     */
+    body(data: BodyInit | null, status?: StatusCode): Response;
+    /**
+     * Stream a response
+     * @param stream - ReadableStream to send
+     * @param status - HTTP status code (default: 200)
+     */
+    stream(stream: ReadableStream, status?: ContentfulStatusCode): Response;
+    /**
+     * Send a 404 Not Found response
+     */
+    notFound(message?: string): Response;
+    /**
+     * Send a 403 Forbidden response
+     */
+    forbidden(message?: string): Response;
+    /**
+     * Send a 401 Unauthorized response
+     */
+    unauthorized(message?: string): Response;
+    /**
+     * Send a 400 Bad Request response
+     */
+    badRequest(message?: string): Response;
+    /**
+     * Forward the current request to another URL (Reverse Proxy)
+     * @param target - Target URL or base URL to forward to
+     * @param options - Optional proxy options
+     */
+    forward(target: string, options?: ProxyOptions): Promise<Response>;
+    /**
+     * Set a response header
+     * @param name - Header name
+     * @param value - Header value
+     * @param options - Options (append: true to add multiple values)
+     */
+    header(name: string, value: string, options?: {
+        append?: boolean;
+    }): void;
+    /**
+     * Get a request header
+     * @param name - Header name (case-insensitive)
+     */
+    header(name: string): string | undefined;
+    /**
+     * Set the response status code
+     * @param code - HTTP status code
+     */
+    status(code: StatusCode): void;
+    /**
+     * Get a context variable
+     * @param key - Variable key
+     */
+    get<K extends keyof V>(key: K): V[K];
+    /**
+     * Set a context variable
+     * @param key - Variable key
+     * @param value - Variable value
+     */
+    set<K extends keyof V>(key: K, value: V[K]): void;
+    /**
+     * Get the execution context (for Cloudflare Workers, etc.)
+     */
+    readonly executionCtx?: ExecutionContext;
+    /**
+     * Get environment bindings (for Cloudflare Workers, etc.)
+     */
+    readonly env?: Record<string, unknown>;
+    /**
+     * URL generator helper.
+     * Generates a URL for a named route.
+     */
+    route: (name: string, params?: Record<string, any>, query?: Record<string, any>) => string;
+    /**
+     * Access the native context object from the underlying HTTP engine.
+     *
+     * ⚠️ WARNING: Using this ties your code to a specific adapter.
+     * Prefer using the abstraction methods when possible.
+     *
+     * @example
+     * ```typescript
+     * // Only when absolutely necessary
+     * const photonCtx = ctx.native as Context // Photon Context
+     * ```
+     */
+    readonly native: unknown;
+}
+/**
+ * Next function for middleware chain
+ */
+export type GravitoNext = () => Promise<Response | undefined>;
+/**
+ * GravitoHandler - Standard route handler type
+ *
+ * @typeParam V - Context variables type
+ *
+ * @example
+ * ```typescript
+ * const handler: GravitoHandler = async (ctx) => {
+ *   return ctx.json({ message: 'Hello, World!' })
+ * }
+ * ```
+ */
+export type GravitoHandler<V extends GravitoVariables = GravitoVariables> = (ctx: GravitoContext<V>) => Response | Promise<Response>;
+/**
+ * GravitoMiddleware - Standard middleware type
+ *
+ * @typeParam V - Context variables type
+ *
+ * @example
+ * ```typescript
+ * const logger: GravitoMiddleware = async (ctx, next) => {
+ *   console.log(`${ctx.req.method} ${ctx.req.path}`)
+ *   await next()
+ *   return undefined
+ * }
+ * ```
+ */
+export type GravitoMiddleware<V extends GravitoVariables = GravitoVariables> = (ctx: GravitoContext<V>, next: GravitoNext) => Response | undefined | Promise<Response | undefined | undefined>;
+/**
+ * Error handler type
+ */
+export type GravitoErrorHandler<V extends GravitoVariables = GravitoVariables> = (error: Error, ctx: GravitoContext<V>) => Response | Promise<Response>;
+/**
+ * Not found handler type
+ */
+export type GravitoNotFoundHandler<V extends GravitoVariables = GravitoVariables> = (ctx: GravitoContext<V>) => Response | Promise<Response>;

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

@@ -0,0 +1,76 @@
+/**
+ * @gravito/core
+ *
+ * The core micro-kernel for the Galaxy Architecture.
+ *
+ * @packageDocumentation
+ */
+import type { GravitoConfig } from './PlanetCore';
+/**
+ * Current version of @gravito/core.
+ * @public
+ */
+export declare const VERSION: string;
+export { GravitoEngineAdapter } from './adapters/GravitoEngineAdapter';
+export { createGravitoAdapter, createPhotonAdapter, GravitoAdapter, PhotonAdapter, PhotonContextWrapper, PhotonRequestWrapper, } from './adapters/PhotonAdapter';
+export type { AdapterConfig, AdapterFactory, HttpAdapter, RouteDefinition } from './adapters/types';
+export { isHttpAdapter } from './adapters/types';
+export type { ContentfulStatusCode, GravitoContext, GravitoErrorHandler, GravitoHandler, GravitoMiddleware, GravitoNext, GravitoNotFoundHandler, GravitoRequest, GravitoVariables, HttpMethod, StatusCode, ValidationTarget, } from './http/types';
+export { Application, type ApplicationConfig } from './Application';
+export { type CommandHandler, CommandKernel } from './CommandKernel';
+export { ConfigManager } from './ConfigManager';
+export { Container, type Factory, type ServiceKey, type ServiceMap } from './Container';
+export { codeFromStatus, ErrorHandler, type ErrorHandlerDeps, messageFromStatus, } from './ErrorHandler';
+export { EventManager } from './EventManager';
+export type { CircuitBreakerOptions, DLQEntry, DLQFilter, EventBackend, EventOptions, EventTask, } from './events';
+export { CircuitBreaker, CircuitBreakerState, DEFAULT_EVENT_OPTIONS, DeadLetterQueue, EventPriorityQueue, } from './events';
+export type { EventTracingConfig, ObservabilityConfig, QueueDepthCallback, } from './events/observability';
+export { EventMetrics, EventTracer, EventTracing, getEventTracing, ObservableHookManager, OTelEventMetrics, } from './events/observability';
+export * from './exceptions';
+export { type GlobalErrorHandlersMode, type GlobalProcessErrorHandlerContext, type GlobalProcessErrorKind, type RegisterGlobalErrorHandlersOptions, registerGlobalErrorHandlers, } from './GlobalErrorHandlers';
+export { type GravitoManifest, GravitoServer } from './GravitoServer';
+export type { ActionCallback, FilterCallback, ListenerInfo, ListenerOptions } from './HookManager';
+export { HookManager, type HookManagerConfig } from './HookManager';
+export * from './helpers';
+export { CookieJar, type CookieOptions } from './http/CookieJar';
+export { deleteCookie, getCookie, setCookie } from './http/cookie';
+export { type BodySizeLimitOptions, bodySizeLimit } from './http/middleware/BodySizeLimit';
+export { type CorsOptions, type CorsOrigin, cors } from './http/middleware/Cors';
+export { type CsrfOptions, csrfProtection, getCsrfToken } from './http/middleware/Csrf';
+export { createHeaderGate, type HeaderTokenGateOptions, type RequireHeaderTokenOptions, requireHeaderToken, } from './http/middleware/HeaderTokenGate';
+export { type HstsOptions, type SecurityHeadersOptions, securityHeaders, } from './http/middleware/SecurityHeaders';
+export { ThrottleRequests } from './http/middleware/ThrottleRequests';
+export * as instrumentation from './instrumentation';
+export { DEFAULT_CONFIG as OTEL_DEFAULT_CONFIG, getMeter, getOpenTelemetrySDK, getTracer as getOtelTracer, isOpenTelemetryInitialized, type MetricsConfig as OtelMetricsConfig, type MetricsExporter, type OpenTelemetryConfig, type OpenTelemetrySDK, OTEL_ENV_VARS, resetOpenTelemetry, setupOpenTelemetry, shutdownOpenTelemetry, type TracingConfig as OtelTracingConfig, type TracingExporter, } from './instrumentation';
+export type { Listener, ShouldQueue } from './Listener';
+export type { Logger } from './Logger';
+export { ConsoleLogger } from './Logger';
+export { type CacheService, type ErrorHandlerContext, type GravitoConfig, type GravitoOrbit, PlanetCore, type ViewService, } from './PlanetCore';
+export { Route } from './Route';
+export { type ControllerClass, FORM_REQUEST_SYMBOL, type FormRequestClass, type FormRequestLike, RouteGroup, type RouteHandler, type RouteOptions, Router, } from './Router';
+export type { DLQManagerFilter, DLQRecord, DLQStats, RetryPolicy } from './reliability';
+export { DeadLetterQueueManager, getDefaultRetryPolicy, getPresetRetryPolicy, RetryEngine, } from './reliability';
+export { ServiceProvider } from './ServiceProvider';
+export { Encrypter, type EncrypterOptions } from './security/Encrypter';
+export type { Channel, ShouldBroadcast } from './types/events';
+export { Event } from './types/events';
+export * from './testing';
+export { createSqliteDatabase, getPasswordAdapter, getRuntimeAdapter, getRuntimeEnv, type RuntimeAdapter, type RuntimeFileStat, type RuntimeKind, type RuntimePasswordAdapter, type RuntimeProcess, type RuntimeServeConfig, type RuntimeServer, type RuntimeSpawnOptions, type RuntimeSqliteDatabase, type RuntimeSqliteStatement, } from './runtime';
+export * as engine from './engine';
+/**
+ * Configure your Gravito application
+ *
+ * @example
+ * ```typescript
+ * const config = defineConfig({
+ *   config: {
+ *     APP_NAME: 'My App',
+ *     PORT: 3000,
+ *   },
+ *   orbits: [], // Add your orbits here
+ * })
+ *
+ * const core = await PlanetCore.boot(config)
+ * ```
+ */
+export declare function defineConfig(config: GravitoConfig): GravitoConfig;

package/dist/core/src/instrumentation/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @gravito/core - Instrumentation Module
+ *
+ * 提供 OpenTelemetry SDK 集成功能，包括分佈式追蹤與指標收集。
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   setupOpenTelemetry,
+ *   getOpenTelemetrySDK,
+ *   getTracer,
+ *   getMeter
+ * } from '@gravito/core'
+ *
+ * // 初始化 SDK
+ * await setupOpenTelemetry({
+ *   serviceName: 'my-service',
+ *   tracing: { enabled: true, exporter: 'jaeger' },
+ *   metrics: { enabled: true, exporter: 'prometheus' }
+ * })
+ *
+ * // 獲取 Tracer
+ * const tracer = await getTracer('my-module')
+ * const span = tracer.startSpan('my-operation')
+ *
+ * // 獲取 Meter
+ * const meter = await getMeter('my-module')
+ * const counter = meter.createCounter('request_count')
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { getMeter, getOpenTelemetrySDK, getTracer, isOpenTelemetryInitialized, resetOpenTelemetry, setupOpenTelemetry, shutdownOpenTelemetry, } from './opentelemetry';
+export type { MetricsConfig, MetricsExporter, OpenTelemetryConfig, OpenTelemetrySDK, TracingConfig, TracingExporter, } from './types';
+export { DEFAULT_CONFIG, OTEL_ENV_VARS } from './types';

package/dist/core/src/instrumentation/opentelemetry.d.ts

@@ -0,0 +1,178 @@
+/**
+ * @gravito/core - OpenTelemetry SDK 集成
+ *
+ * 提供 OpenTelemetry 的初始化、配置與管理功能。
+ * 支援動態導入以實現可選依賴的優雅降級。
+ *
+ * @example
+ * ```typescript
+ * import { setupOpenTelemetry } from '@gravito/core'
+ *
+ * const sdk = await setupOpenTelemetry({
+ *   serviceName: 'my-service',
+ *   serviceVersion: '1.0.0',
+ *   tracing: {
+ *     enabled: true,
+ *     exporter: 'jaeger',
+ *     samplingRate: 0.1
+ *   },
+ *   metrics: {
+ *     enabled: true,
+ *     exporter: 'prometheus',
+ *     prometheusPort: 9090
+ *   }
+ * })
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { type MetricsConfig, type OpenTelemetryConfig, type OpenTelemetrySDK, type TracingConfig } from './types';
+export type { MetricsConfig, OpenTelemetryConfig, OpenTelemetrySDK, TracingConfig };
+/**
+ * 初始化 OpenTelemetry SDK
+ *
+ * @param userConfig - 用戶配置
+ * @returns OpenTelemetry SDK 實例或 null（如果禁用或初始化失敗）
+ *
+ * @example
+ * ```typescript
+ * // 基本用法
+ * const sdk = await setupOpenTelemetry({
+ *   serviceName: 'my-service'
+ * })
+ *
+ * // 完整配置
+ * const sdk = await setupOpenTelemetry({
+ *   serviceName: 'my-service',
+ *   serviceVersion: '2.0.0',
+ *   environment: 'production',
+ *   tracing: {
+ *     enabled: true,
+ *     exporter: 'jaeger',
+ *     jaegerEndpoint: 'http://jaeger:14268/api/traces',
+ *     samplingRate: 0.1
+ *   },
+ *   metrics: {
+ *     enabled: true,
+ *     exporter: 'prometheus',
+ *     prometheusPort: 9090
+ *   }
+ * })
+ * ```
+ *
+ * @public
+ */
+export declare function setupOpenTelemetry(userConfig?: OpenTelemetryConfig): Promise<OpenTelemetrySDK | null>;
+/**
+ * 獲取全局 OpenTelemetry SDK 實例
+ *
+ * @returns SDK 實例或 null
+ *
+ * @example
+ * ```typescript
+ * const sdk = getOpenTelemetrySDK()
+ * if (sdk) {
+ *   console.log('Service:', sdk.serviceName)
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function getOpenTelemetrySDK(): OpenTelemetrySDK | null;
+/**
+ * 檢查 OpenTelemetry 是否已初始化
+ *
+ * @returns 初始化狀態
+ *
+ * @public
+ */
+export declare function isOpenTelemetryInitialized(): boolean;
+/**
+ * 關閉 OpenTelemetry SDK
+ *
+ * 應在應用程序關閉時調用，確保所有 spans 和 metrics 都被導出。
+ *
+ * @example
+ * ```typescript
+ * // 在應用程序退出前
+ * process.on('SIGTERM', async () => {
+ *   await shutdownOpenTelemetry()
+ *   process.exit(0)
+ * })
+ * ```
+ *
+ * @public
+ */
+export declare function shutdownOpenTelemetry(): Promise<void>;
+/**
+ * 重置 OpenTelemetry SDK（主要用於測試）
+ *
+ * 關閉現有 SDK 並重置所有狀態，允許重新初始化。
+ *
+ * @internal
+ */
+export declare function resetOpenTelemetry(): Promise<void>;
+/**
+ * 獲取 Tracer 實例
+ *
+ * @param name - Tracer 名稱（預設：@gravito/core）
+ * @param version - Tracer 版本
+ * @returns Tracer 實例
+ *
+ * @example
+ * ```typescript
+ * const tracer = getTracer('my-module')
+ * const span = tracer.startSpan('my-operation')
+ * // ... 執行操作
+ * span.end()
+ * ```
+ *
+ * @public
+ */
+export declare function getTracer(name?: string, version?: string): Promise<import("@opentelemetry/api").Tracer | {
+    startSpan: () => {
+        end: () => void;
+        setAttribute: () => void;
+        setStatus: () => void;
+        recordException: () => void;
+        addEvent: () => void;
+        isRecording: () => boolean;
+    };
+    startActiveSpan: (_name: string, fn: (span: any) => any) => any;
+}>;
+/**
+ * 獲取 Meter 實例
+ *
+ * @param name - Meter 名稱（預設：@gravito/core）
+ * @param version - Meter 版本
+ * @returns Meter 實例
+ *
+ * @example
+ * ```typescript
+ * const meter = getMeter('my-module')
+ * const counter = meter.createCounter('my_counter')
+ * counter.add(1, { key: 'value' })
+ * ```
+ *
+ * @public
+ */
+export declare function getMeter(name?: string, version?: string): Promise<import("@opentelemetry/api").Meter | {
+    createCounter: () => {
+        add: () => void;
+    };
+    createHistogram: () => {
+        record: () => void;
+    };
+    createUpDownCounter: () => {
+        add: () => void;
+    };
+    createObservableCounter: () => {
+        addCallback: () => void;
+    };
+    createObservableGauge: () => {
+        addCallback: () => void;
+    };
+    createObservableUpDownCounter: () => {
+        addCallback: () => void;
+    };
+}>;