@depup/sentry__node 10.75.2-depup.0 → 11.1.0-depup.0

package/build/types-ts3.8/integrations/tracing/amqplib/vendored/types.d.ts

@@ -1,49 +0,0 @@
-export declare enum EndOperation {
-    AutoAck = "auto ack",
-    Ack = "ack",
-    AckAll = "ackAll",
-    Reject = "reject",
-    Nack = "nack",
-    NackAll = "nackAll",
-    ChannelClosed = "channel closed",
-    ChannelError = "channel error",
-    InstrumentationTimeout = "instrumentation timeout"
-}
-export interface Message {
-    content: Buffer;
-    fields: MessageFields;
-    properties: MessageProperties;
-}
-export interface ConsumeMessage extends Message {
-    fields: ConsumeMessageFields;
-}
-export interface CommonMessageFields {
-    deliveryTag: number;
-    redelivered: boolean;
-    exchange: string;
-    routingKey: string;
-}
-export interface MessageFields extends CommonMessageFields {
-    messageCount?: number;
-    consumerTag?: string;
-}
-export interface ConsumeMessageFields extends CommonMessageFields {
-    deliveryTag: number;
-}
-export interface MessageProperties {
-    contentType: any | undefined;
-    contentEncoding: any | undefined;
-    headers: any;
-    deliveryMode: any | undefined;
-    priority: any | undefined;
-    correlationId: any | undefined;
-    replyTo: any | undefined;
-    expiration: any | undefined;
-    messageId: any | undefined;
-    timestamp: any | undefined;
-    type: any | undefined;
-    userId: any | undefined;
-    appId: any | undefined;
-    clusterId: any | undefined;
-}
-//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/integrations/tracing/amqplib/vendored/utils.d.ts

@@ -1,42 +0,0 @@
-import { Span, SpanAttributes } from '@sentry/core';
-import { Channel, ConfirmChannel, Connection, Options } from './amqplib-types';
-import { ConsumeMessage, Message } from './types';
-export declare const MESSAGE_STORED_SPAN: unique symbol;
-export declare const CHANNEL_SPANS_NOT_ENDED: unique symbol;
-export declare const CHANNEL_CONSUME_TIMEOUT_TIMER: unique symbol;
-export declare const CONNECTION_ATTRIBUTES: unique symbol;
-export declare const CHANNEL_IS_CONFIRM_PUBLISHING: unique symbol;
-export type InstrumentationConnection = Connection & {
-    [CONNECTION_ATTRIBUTES]?: SpanAttributes;
-};
-export type InstrumentationPublishChannel = (Channel | ConfirmChannel) & {
-    connection: InstrumentationConnection;
-    [CHANNEL_IS_CONFIRM_PUBLISHING]?: boolean;
-};
-export type InstrumentationConsumeChannel = Channel & {
-    connection: InstrumentationConnection;
-    [CHANNEL_SPANS_NOT_ENDED]?: {
-        msg: ConsumeMessage;
-        timeOfConsume: number;
-    }[];
-    [CHANNEL_CONSUME_TIMEOUT_TIMER]?: NodeJS.Timeout;
-};
-export type InstrumentationMessage = Message & {
-    [MESSAGE_STORED_SPAN]?: Span;
-};
-export type InstrumentationConsumeMessage = ConsumeMessage & {
-    [MESSAGE_STORED_SPAN]?: Span;
-};
-export declare const normalizeExchange: (exchangeName: string) => string;
-export declare const getConnectionAttributesFromServer: (conn: Connection) => SpanAttributes;
-export declare const getConnectionAttributesFromUrl: (url: string | Options.Connect) => SpanAttributes;
-/** Reads a propagation header value off an amqplib message as a string. */
-export declare function getHeaderAsString(headers: Record<string, unknown> | undefined, key: string): string | undefined;
-/** Starts an inactive producer span and propagates its trace into the publish `options.headers`. */
-export declare function startPublishSpan(exchange: string, routingKey: string, channel: InstrumentationPublishChannel, options?: Options.Publish): {
-    span: Span;
-    modifiedOptions: Options.Publish;
-};
-/** Starts an inactive consumer (process) span carrying the amqplib messaging attributes. */
-export declare function startConsumeSpan(queue: string, msg: InstrumentationConsumeMessage, channel: InstrumentationConsumeChannel): Span;
-//# sourceMappingURL=utils.d.ts.map

package/build/types-ts3.8/integrations/tracing/anthropic-ai/index.d.ts

@@ -1,62 +0,0 @@
-import { AnthropicAiOptions } from '@sentry/core';
-export declare const instrumentAnthropicAi: ((options?: AnthropicAiOptions | undefined) => import("@opentelemetry/instrumentation").Instrumentation<import("@opentelemetry/instrumentation").InstrumentationConfig>) & {
-    id: string;
-};
-/**
- * Adds Sentry tracing instrumentation for the Anthropic AI SDK.
- *
- * This integration is enabled by default.
- *
- * When configured, this integration automatically instruments Anthropic AI SDK client instances
- * to capture telemetry data following OpenTelemetry Semantic Conventions for Generative AI.
- *
- * @example
- * ```javascript
- * import * as Sentry from '@sentry/node';
- *
- * Sentry.init({
- *   integrations: [Sentry.anthropicAIIntegration()],
- * });
- * ```
- *
- * ## Options
- *
- * - `recordInputs`: Whether to record prompt messages (default: follows `dataCollection.genAI.inputs`, or the deprecated `sendDefaultPii` option)
- * - `recordOutputs`: Whether to record response text (default: follows `dataCollection.genAI.outputs`, or the deprecated `sendDefaultPii` option)
- *
- * ### Default Behavior
- *
- * By default, the integration will:
- * - Record inputs and outputs based on `dataCollection.genAI` in your Sentry client options
- *   (or the deprecated `sendDefaultPii` option, for backwards compatibility)
- * - Integration-level `recordInputs`/`recordOutputs` options take precedence over global config
- *
- * @example
- * ```javascript
- * // Always record inputs and outputs regardless of global dataCollection config
- * Sentry.init({
- *   integrations: [
- *     Sentry.anthropicAIIntegration({
- *       recordInputs: true,
- *       recordOutputs: true
- *     })
- *   ],
- * });
- *
- * // Never record inputs/outputs regardless of global dataCollection config
- * Sentry.init({
- *   dataCollection: { genAI: { inputs: true, outputs: true } },
- *   integrations: [
- *     Sentry.anthropicAIIntegration({
- *       recordInputs: false,
- *       recordOutputs: false
- *     })
- *   ],
- * });
- * ```
- *
- */
-export declare const anthropicAIIntegration: (options?: AnthropicAiOptions | undefined) => import("@sentry/core").Integration & {
-    name: "Anthropic_AI";
-};
-//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/anthropic-ai/instrumentation.d.ts

@@ -1,19 +0,0 @@
-import { InstrumentationBase, InstrumentationConfig, InstrumentationModuleDefinition } from '@opentelemetry/instrumentation';
-import { AnthropicAiOptions } from '@sentry/core';
-type AnthropicAiInstrumentationOptions = InstrumentationConfig & AnthropicAiOptions;
-/**
- * Sentry Anthropic AI instrumentation using OpenTelemetry.
- */
-export declare class SentryAnthropicAiInstrumentation extends InstrumentationBase<AnthropicAiInstrumentationOptions> {
-    constructor(config?: AnthropicAiInstrumentationOptions);
-    /**
-     * Initializes the instrumentation by defining the modules to be patched.
-     */
-    init(): InstrumentationModuleDefinition;
-    /**
-     * Core patch logic applying instrumentation to the Anthropic AI client constructor.
-     */
-    private _patch;
-}
-export {};
-//# sourceMappingURL=instrumentation.d.ts.map

package/build/types-ts3.8/integrations/tracing/connect/index.d.ts

@@ -1,48 +0,0 @@
-import { ConnectInstrumentation } from './vendored/instrumentation';
-type ConnectApp = {
-    use: (middleware: any) => void;
-};
-export declare const instrumentConnect: ((options?: unknown) => ConnectInstrumentation) & {
-    id: string;
-};
-/**
- * Adds Sentry tracing instrumentation for [Connect](https://github.com/senchalabs/connect/).
- *
- * If you also want to capture errors, you need to call `setupConnectErrorHandler(app)` after you initialize your connect app.
- *
- * For more information, see the [connect documentation](https://docs.sentry.io/platforms/javascript/guides/connect/).
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- *
- * Sentry.init({
- *   integrations: [Sentry.connectIntegration()],
- * })
- * ```
- */
-export declare const connectIntegration: () => import("@sentry/core").Integration & {
-    name: "Connect";
-};
-/**
- * Add a Connect middleware to capture errors to Sentry.
- *
- * @param app The Connect app to attach the error handler to
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- * const connect = require("connect");
- *
- * const app = connect();
- *
- * Sentry.setupConnectErrorHandler(app);
- *
- * // Add you connect routes here
- *
- * app.listen(3000);
- * ```
- */
-export declare const setupConnectErrorHandler: (app: ConnectApp) => void;
-export {};
-//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/connect/vendored/enums/AttributeNames.d.ts

@@ -1,9 +0,0 @@
-export declare enum AttributeNames {
-    CONNECT_TYPE = "connect.type",
-    CONNECT_NAME = "connect.name"
-}
-export declare enum ConnectTypes {
-    MIDDLEWARE = "middleware",
-    REQUEST_HANDLER = "request_handler"
-}
-//# sourceMappingURL=AttributeNames.d.ts.map

package/build/types-ts3.8/integrations/tracing/connect/vendored/instrumentation.d.ts

@@ -1,18 +0,0 @@
-import { HandleFunction, NextFunction, Server, Use } from './internal-types';
-import { Span } from '@sentry/core';
-import { InstrumentationConfig } from '@opentelemetry/instrumentation';
-import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-/** Connect instrumentation for OpenTelemetry */
-export declare class ConnectInstrumentation extends InstrumentationBase {
-    constructor(config?: InstrumentationConfig);
-    init(): InstrumentationNodeModuleDefinition[];
-    private _patchApp;
-    private _patchConstructor;
-    _patchNext(next: NextFunction, span: Span, finishSpan: () => void): NextFunction;
-    _startSpan(routeName: string, middleWare: HandleFunction): Span;
-    _patchMiddleware(routeName: string, middleWare: HandleFunction): HandleFunction;
-    _patchUse(original: Server['use']): Use;
-    _patchHandle(original: Server['handle']): Server['handle'];
-    _patchOut(out: NextFunction, completeStack: () => void): NextFunction;
-}
-//# sourceMappingURL=instrumentation.d.ts.map

package/build/types-ts3.8/integrations/tracing/connect/vendored/internal-types.d.ts

@@ -1,36 +0,0 @@
-import * as http from 'http';
-export type IncomingMessage = http.IncomingMessage & {
-    originalUrl?: http.IncomingMessage['url'] | undefined;
-};
-export type NextFunction = (err?: unknown) => void;
-export type SimpleHandleFunction = (req: IncomingMessage, res: http.ServerResponse) => void;
-export type NextHandleFunction = (req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
-export type ErrorHandleFunction = (err: unknown, req: IncomingMessage, res: http.ServerResponse, next: NextFunction) => void;
-export type HandleFunction = SimpleHandleFunction | NextHandleFunction | ErrorHandleFunction;
-export interface Server extends NodeJS.EventEmitter {
-    (req: http.IncomingMessage, res: http.ServerResponse, next?: Function): void;
-    route: string;
-    stack: Array<{
-        route: string;
-        handle: HandleFunction | http.Server;
-    }>;
-    use(fn: NextHandleFunction): Server;
-    use(fn: HandleFunction): Server;
-    use(route: string, fn: NextHandleFunction): Server;
-    use(route: string, fn: HandleFunction): Server;
-    handle(req: http.IncomingMessage, res: http.ServerResponse, next: Function): void;
-}
-export declare const _LAYERS_STORE_PROPERTY: unique symbol;
-export type UseArgs1 = [
-    HandleFunction
-];
-export type UseArgs2 = [
-    string,
-    HandleFunction
-];
-export type UseArgs = UseArgs1 | UseArgs2;
-export type Use = (...args: UseArgs) => Server;
-export type PatchedRequest = {
-    [_LAYERS_STORE_PROPERTY]: string[];
-} & IncomingMessage;
-//# sourceMappingURL=internal-types.d.ts.map

package/build/types-ts3.8/integrations/tracing/connect/vendored/utils.d.ts

@@ -1,5 +0,0 @@
-import { PatchedRequest } from './internal-types';
-export declare const addNewStackLayer: (request: PatchedRequest) => () => void;
-export declare const replaceCurrentStackRoute: (request: PatchedRequest, newRoute?: string) => void;
-export declare const generateRoute: (request: PatchedRequest) => string;
-//# sourceMappingURL=utils.d.ts.map

package/build/types-ts3.8/integrations/tracing/dataloader/index.d.ts

@@ -1,22 +0,0 @@
-import { DataloaderInstrumentation } from './vendored/instrumentation';
-export declare const instrumentDataloader: ((options?: unknown) => DataloaderInstrumentation) & {
-    id: string;
-};
-/**
- * Adds Sentry tracing instrumentation for the [dataloader](https://www.npmjs.com/package/dataloader) library.
- *
- * For more information, see the [`dataloaderIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/dataloader/).
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- *
- * Sentry.init({
- *  integrations: [Sentry.dataloaderIntegration()],
- * });
- * ```
- */
-export declare const dataloaderIntegration: () => import("@sentry/core").Integration & {
-    name: "Dataloader";
-};
-//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/dataloader/vendored/instrumentation.d.ts

@@ -1,18 +0,0 @@
-import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-export declare class DataloaderInstrumentation extends InstrumentationBase {
-    constructor(config?: {});
-    protected init(): InstrumentationNodeModuleDefinition[];
-    private _wrapBatchLoadFn;
-    private _getPatchedConstructor;
-    private _patchLoad;
-    private _getPatchedLoad;
-    private _patchLoadMany;
-    private _getPatchedLoadMany;
-    private _patchPrime;
-    private _getPatchedPrime;
-    private _patchClear;
-    private _getPatchedClear;
-    private _patchClearAll;
-    private _getPatchedClearAll;
-}
-//# sourceMappingURL=instrumentation.d.ts.map

package/build/types-ts3.8/integrations/tracing/dataloader/vendored/types.d.ts

@@ -1,22 +0,0 @@
-import { SpanLink } from '@sentry/core';
-export type BatchLoadFn<K, V> = (keys: ReadonlyArray<K>) => PromiseLike<ArrayLike<V | Error>>;
-/** A `DataLoader` instance. */
-export interface DataLoader<K = unknown, V = unknown> {
-    _batchLoadFn: BatchLoadFn<K, V>;
-    _batch: {
-        spanLinks?: SpanLink[];
-    } | null;
-    load(key: K): Promise<V>;
-    loadMany(keys: ArrayLike<K>): Promise<Array<V | Error>>;
-    prime(key: K, value: V | Error): this;
-    clear(key: K): this;
-    clearAll(): this;
-    name: string | undefined;
-    [key: string]: any;
-}
-/** The `DataLoader` class/constructor. */
-export interface DataLoaderConstructor {
-    new <K, V>(batchLoadFn: BatchLoadFn<K, V>, options?: any): DataLoader<K, V>;
-    prototype: DataLoader<unknown, unknown>;
-}
-//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/integrations/tracing/express.d.ts

@@ -1,19 +0,0 @@
-import { InstrumentationConfig } from '@opentelemetry/instrumentation';
-import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { ExpressIntegrationOptions, ExpressHandlerOptions } from '@sentry/core';
-export { expressErrorHandler } from '@sentry/core';
-export declare function setupExpressErrorHandler(app: {
-    use: (middleware: any) => unknown;
-}, options?: ExpressHandlerOptions): void;
-export type ExpressInstrumentationConfig = InstrumentationConfig & Pick<ExpressIntegrationOptions, Exclude<keyof ExpressIntegrationOptions, 'express' | 'onRouteResolved'>>;
-export declare const instrumentExpress: ((options?: ExpressInstrumentationConfig | undefined) => ExpressInstrumentation) & {
-    id: string;
-};
-export declare class ExpressInstrumentation extends InstrumentationBase<ExpressInstrumentationConfig> {
-    constructor(config?: ExpressInstrumentationConfig);
-    init(): InstrumentationNodeModuleDefinition;
-}
-export declare const expressIntegration: (options?: ExpressInstrumentationConfig | undefined) => import("@sentry/core").Integration & {
-    name: "Express";
-};
-//# sourceMappingURL=express.d.ts.map

package/build/types-ts3.8/integrations/tracing/fastify/index.d.ts

@@ -1,124 +0,0 @@
-import { Integration } from '@sentry/core';
-import { FastifyMinimal, FastifyReply, FastifyRequest } from './types';
-import { FastifyInstrumentationV3 } from './v3/instrumentation';
-import { instrumentFastify } from '@sentry/server-utils';
-export { instrumentFastify };
-/**
- * Options for the Fastify integration.
- *
- * `shouldHandleError` - Callback method deciding whether error should be captured and sent to Sentry
- *
- * @example
- *
- * ```javascript
- * Sentry.init({
- *   integrations: [
- *     Sentry.fastifyIntegration({
- *       shouldHandleError(_error, _request, reply) {
- *         return reply.statusCode >= 500;
- *       },
- *     });
- *   },
- * });
- * ```
- *
- */
-interface FastifyIntegrationOptions {
-    /**
-     * Callback method deciding whether error should be captured and sent to Sentry
-     * This is used on Fastify v5 where Sentry handles errors in the diagnostics channel.
-     * Fastify v3 and v4 use `setupFastifyErrorHandler` instead.
-     *
-     * @param error Captured Fastify error
-     * @param request Fastify request (or any object containing at least method, routeOptions.url, and routerPath)
-     * @param reply Fastify reply (or any object containing at least statusCode)
-     *
-     * @example
-     *
-     * If using TypeScript, you can cast the request and reply to get full type safety.
-     *
-     * ```typescript
-     * import type { FastifyRequest, FastifyReply } from 'fastify';
-     *
-     * Sentry.fastifyIntegration({
-     *   shouldHandleError(error, minimalRequest, minimalReply) {
-     *     const request = minimalRequest as FastifyRequest;
-     *     const reply = minimalReply as FastifyReply;
-     *     return reply.statusCode >= 500;
-     *   },
-     * });
-     * ```
-     */
-    shouldHandleError: (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean;
-}
-interface FastifyHandlerOptions {
-    /**
-     * Callback method deciding whether error should be captured and sent to Sentry
-     *
-     * @param error Captured Fastify error
-     * @param request Fastify request (or any object containing at least method, routeOptions.url, and routerPath)
-     * @param reply Fastify reply (or any object containing at least statusCode)
-     *
-     * @deprecated Configure `shouldHandleError` on `fastifyIntegration()` rather than here, where it
-     * applies to every supported Fastify version. This option will be removed in v11.
-     *
-     * @example
-     *
-     * ```javascript
-     * Sentry.init({
-     *   integrations: [
-     *     Sentry.fastifyIntegration({
-     *       shouldHandleError(_error, _request, reply) {
-     *         return reply.statusCode >= 500;
-     *       },
-     *     }),
-     *   ],
-     * });
-     * ```
-     */
-    shouldHandleError: (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean;
-}
-export declare const instrumentFastifyV3: ((options?: unknown) => FastifyInstrumentationV3) & {
-    id: string;
-};
-/**
- * Adds Sentry tracing instrumentation for [Fastify](https://fastify.dev/).
- *
- * If you also want to capture errors, you need to call `setupFastifyErrorHandler(app)` after you set up your Fastify server.
- *
- * For more information, see the [fastify documentation](https://docs.sentry.io/platforms/javascript/guides/fastify/).
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- *
- * Sentry.init({
- *   integrations: [Sentry.fastifyIntegration()],
- * })
- * ```
- */
-export declare const fastifyIntegration: (options?: Partial<FastifyIntegrationOptions> | undefined) => Integration & {
-    name: string;
-};
-/**
- * Add an Fastify error handler to capture errors to Sentry.
- *
- * @param fastify The Fastify instance to which to add the error handler
- * @param options Configuration options for the handler
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- * const Fastify = require("fastify");
- *
- * const app = Fastify();
- *
- * Sentry.setupFastifyErrorHandler(app);
- *
- * // Add your routes, etc.
- *
- * app.listen({ port: 3000 });
- * ```
- */
-export declare function setupFastifyErrorHandler(fastify: FastifyMinimal, options?: Partial<FastifyHandlerOptions>): void;
-//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/fastify/types.d.ts

@@ -1,33 +0,0 @@
-export type HandlerOriginal = ((request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction) => Promise<void>) | ((request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction) => void);
-export type FastifyError = any;
-export type HookHandlerDoneFunction = <TError extends Error = FastifyError>(err?: TError) => void;
-export type FastifyErrorCodes = any;
-export type FastifyPlugin = (instance: FastifyInstance, opts: any, done: HookHandlerDoneFunction) => unknown | Promise<unknown>;
-export interface FastifyInstance {
-    version: string;
-    register: (plugin: any) => FastifyInstance;
-    after: (listener?: (err: Error) => void) => FastifyInstance;
-    addHook(hook: string, handler: HandlerOriginal): FastifyInstance;
-    addHook(hook: 'onError', handler: (request: FastifyRequest, reply: FastifyReply, error: Error) => void): FastifyInstance;
-    addHook(hook: 'onRequest', handler: (request: FastifyRequest, reply: FastifyReply) => void): FastifyInstance;
-}
-/**
- * Minimal type for `setupFastifyErrorHandler` parameter.
- * Uses structural typing without overloads to avoid exactOptionalPropertyTypes issues.
- * https://github.com/getsentry/sentry-javascript/issues/18619
- */
-export type FastifyMinimal = {
-    register: (plugin: (instance: any, opts: any, done: () => void) => void) => unknown;
-};
-export interface FastifyReply {
-    send: () => FastifyReply;
-    statusCode: number;
-}
-export interface FastifyRequest {
-    method?: string;
-    routeOptions?: {
-        url?: string;
-    };
-    routerPath?: string;
-}
-//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/integrations/tracing/fastify/v3/constants.d.ts

@@ -1,3 +0,0 @@
-export declare const spanRequestSymbol: unique symbol;
-export declare const hooksNamesToWrap: Set<string>;
-//# sourceMappingURL=constants.d.ts.map

package/build/types-ts3.8/integrations/tracing/fastify/v3/enums/AttributeNames.d.ts

@@ -1,15 +0,0 @@
-export declare enum AttributeNames {
-    FASTIFY_NAME = "fastify.name",
-    FASTIFY_TYPE = "fastify.type",
-    HOOK_NAME = "hook.name",
-    PLUGIN_NAME = "plugin.name"
-}
-export declare enum FastifyTypes {
-    MIDDLEWARE = "middleware",
-    REQUEST_HANDLER = "request_handler"
-}
-export declare enum FastifyNames {
-    MIDDLEWARE = "middleware",
-    REQUEST_HANDLER = "request handler"
-}
-//# sourceMappingURL=AttributeNames.d.ts.map

package/build/types-ts3.8/integrations/tracing/fastify/v3/instrumentation.d.ts

@@ -1,16 +0,0 @@
-import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { FastifyInstrumentationConfig } from './types';
-/**
- * Fastify instrumentation for OpenTelemetry
- */
-export declare class FastifyInstrumentationV3 extends InstrumentationBase<FastifyInstrumentationConfig> {
-    constructor(config?: FastifyInstrumentationConfig);
-    init(): InstrumentationNodeModuleDefinition[];
-    private _hookOnRequest;
-    private _wrapHandler;
-    private _wrapAddHook;
-    private _patchConstructor;
-    private _patchSend;
-    private _hookPreHandler;
-}
-//# sourceMappingURL=instrumentation.d.ts.map

package/build/types-ts3.8/integrations/tracing/fastify/v3/internal-types.d.ts

@@ -1,7 +0,0 @@
-import { Span } from '@opentelemetry/api';
-import { FastifyReply } from '../types';
-import { spanRequestSymbol } from './constants';
-export type PluginFastifyReply = FastifyReply & {
-    [spanRequestSymbol]?: Span[];
-};
-//# sourceMappingURL=internal-types.d.ts.map

package/build/types-ts3.8/integrations/tracing/fastify/v3/types.d.ts

@@ -1,21 +0,0 @@
-import { Span } from '@opentelemetry/api';
-import { InstrumentationConfig } from '@opentelemetry/instrumentation';
-export interface FastifyRequestInfo {
-    request: any;
-}
-/**
- * Function that can be used to add custom attributes to the current span
- * @param span - The Fastify handler span.
- * @param info - The Fastify request info object.
- */
-export interface FastifyCustomAttributeFunction {
-    (span: Span, info: FastifyRequestInfo): void;
-}
-/**
- * Options available for the Fastify Instrumentation
- */
-export interface FastifyInstrumentationConfig extends InstrumentationConfig {
-    /** Function for adding custom attributes to each handler span */
-    requestHook?: FastifyCustomAttributeFunction;
-}
-//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/integrations/tracing/fastify/v3/utils.d.ts

@@ -1,28 +0,0 @@
-import { Attributes, Span, Tracer } from '@opentelemetry/api';
-import { PluginFastifyReply } from './internal-types';
-/**
- * Starts Span
- * @param reply - reply function
- * @param tracer - tracer
- * @param spanName - span name
- * @param spanAttributes - span attributes
- */
-export declare function startSpan(reply: PluginFastifyReply, tracer: Tracer, spanName: string, spanAttributes?: Attributes): Span;
-/**
- * Ends span
- * @param reply - reply function
- * @param err - error
- */
-export declare function endSpan(reply: PluginFastifyReply, err?: any): void;
-/**
- * This function handles the missing case from instrumentation package when
- * execute can either return a promise or void. And using async is not an
- * option as it is producing unwanted side effects.
- * @param execute - function to be executed
- * @param onFinish - function called when function executed
- * @param preventThrowingError - prevent to throw error when execute
- * function fails
- */
-export declare function safeExecuteInTheMiddleMaybePromise<T>(execute: () => Promise<T>, onFinish: (e: unknown, result?: T) => void, preventThrowingError?: boolean): Promise<T>;
-export declare function safeExecuteInTheMiddleMaybePromise<T>(execute: () => T, onFinish: (e: unknown, result?: T) => void, preventThrowingError?: boolean): T;
-//# sourceMappingURL=utils.d.ts.map

package/build/types-ts3.8/integrations/tracing/firebase/firebase.d.ts

@@ -1,8 +0,0 @@
-import { FirebaseInstrumentation } from './otel';
-export declare const instrumentFirebase: ((options?: unknown) => FirebaseInstrumentation) & {
-    id: string;
-};
-export declare const firebaseIntegration: () => import("@sentry/core").Integration & {
-    name: "Firebase";
-};
-//# sourceMappingURL=firebase.d.ts.map

package/build/types-ts3.8/integrations/tracing/firebase/index.d.ts

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