@depup/sentry__node 10.47.0-depup.1 → 10.67.0-depup.0

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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -21,18 +21,19 @@ export declare const instrumentAnthropicAi: ((options?: AnthropicAiOptions | und
  *
  * ## Options
  *
- * - `recordInputs`: Whether to record prompt messages (default: respects `sendDefaultPii` client option)
- * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client option)
+ * - `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 ONLY if `sendDefaultPii` is set to `true` in your Sentry client options
- * - Otherwise, inputs and outputs are NOT recorded unless explicitly enabled
+ * - 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
- * // Record inputs and outputs when sendDefaultPii is false
+ * // Always record inputs and outputs regardless of global dataCollection config
  * Sentry.init({
  *   integrations: [
  *     Sentry.anthropicAIIntegration({
@@ -42,9 +43,9 @@ export declare const instrumentAnthropicAi: ((options?: AnthropicAiOptions | und
  *   ],
  * });
  *
- * // Never record inputs/outputs regardless of sendDefaultPii
+ * // Never record inputs/outputs regardless of global dataCollection config
  * Sentry.init({
- *   sendDefaultPii: true,
+ *   dataCollection: { genAI: { inputs: true, outputs: true } },
  *   integrations: [
  *     Sentry.anthropicAIIntegration({
  *       recordInputs: false,
@@ -55,5 +56,7 @@ export declare const instrumentAnthropicAi: ((options?: AnthropicAiOptions | und
  * ```
  *
  */
-export declare const anthropicAIIntegration: (options?: AnthropicAiOptions | undefined) => import("@sentry/core").Integration;
+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/{connect.d.ts → connect/index.d.ts}

@@ -1,4 +1,4 @@
-import { ConnectInstrumentation } from '@opentelemetry/instrumentation-connect';
+import { ConnectInstrumentation } from './vendored/instrumentation';
 type ConnectApp = {
     use: (middleware: any) => void;
 };
@@ -21,7 +21,9 @@ export declare const instrumentConnect: ((options?: unknown) => ConnectInstrumen
  * })
  * ```
  */
-export declare const connectIntegration: () => import("@sentry/core").Integration;
+export declare const connectIntegration: () => import("@sentry/core").Integration & {
+    name: "Connect";
+};
 /**
  * Add a Connect middleware to capture errors to Sentry.
  *
@@ -43,4 +45,4 @@ export declare const connectIntegration: () => import("@sentry/core").Integratio
  */
 export declare const setupConnectErrorHandler: (app: ConnectApp) => void;
 export {};
-//# sourceMappingURL=connect.d.ts.map
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,5 @@
+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.d.ts → dataloader/index.d.ts}

@@ -1,4 +1,4 @@
-import { DataloaderInstrumentation } from '@opentelemetry/instrumentation-dataloader';
+import { DataloaderInstrumentation } from './vendored/instrumentation';
 export declare const instrumentDataloader: ((options?: unknown) => DataloaderInstrumentation) & {
     id: string;
 };
@@ -16,5 +16,7 @@ export declare const instrumentDataloader: ((options?: unknown) => DataloaderIns
  * });
  * ```
  */
-export declare const dataloaderIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=dataloader.d.ts.map
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,22 @@
+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,72 +1,19 @@
-import * as http from 'node:http';
-import { ExpressInstrumentation } from '@opentelemetry/instrumentation-express';
-export declare const instrumentExpress: ((options?: unknown) => ExpressInstrumentation) & {
+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;
 };
-/**
- * Adds Sentry tracing instrumentation for [Express](https://expressjs.com/).
- *
- * If you also want to capture errors, you need to call `setupExpressErrorHandler(app)` after you set up your Express server.
- *
- * For more information, see the [express documentation](https://docs.sentry.io/platforms/javascript/guides/express/).
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- *
- * Sentry.init({
- *   integrations: [Sentry.expressIntegration()],
- * })
- * ```
- */
-export declare const expressIntegration: () => import("@sentry/core").Integration;
-interface MiddlewareError extends Error {
-    status?: number | string;
-    statusCode?: number | string;
-    status_code?: number | string;
-    output?: {
-        statusCode?: number | string;
-    };
-}
-type ExpressMiddleware = (req: http.IncomingMessage, res: http.ServerResponse, next: () => void) => void;
-type ExpressErrorMiddleware = (error: MiddlewareError, req: http.IncomingMessage, res: http.ServerResponse, next: (error: MiddlewareError) => void) => void;
-interface ExpressHandlerOptions {
-    /**
-     * Callback method deciding whether error should be captured and sent to Sentry
-     * @param error Captured middleware error
-     */
-    shouldHandleError?(this: void, error: MiddlewareError): boolean;
+export declare class ExpressInstrumentation extends InstrumentationBase<ExpressInstrumentationConfig> {
+    constructor(config?: ExpressInstrumentationConfig);
+    init(): InstrumentationNodeModuleDefinition;
 }
-/**
- * An Express-compatible error handler.
- */
-export declare function expressErrorHandler(options?: ExpressHandlerOptions): ExpressErrorMiddleware;
-/**
- * Add an Express error handler to capture errors to Sentry.
- *
- * The error handler must be before any other middleware and after all controllers.
- *
- * @param app The Express instances
- * @param options {ExpressHandlerOptions} Configuration options for the handler
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- * const express = require("express");
- *
- * const app = express();
- *
- * // Add your routes, etc.
- *
- * // Add this after all routes,
- * // but before any and other error-handling middlewares are defined
- * Sentry.setupExpressErrorHandler(app);
- *
- * app.listen(3000);
- * ```
- */
-export declare function setupExpressErrorHandler(app: {
-    use: (middleware: ExpressMiddleware | ExpressErrorMiddleware) => unknown;
-}, options?: ExpressHandlerOptions): void;
-export {};
+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,6 +1,8 @@
-import { Instrumentation, InstrumentationConfig } from '@opentelemetry/instrumentation';
+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.
  *
@@ -74,9 +76,6 @@ interface FastifyHandlerOptions {
 export declare const instrumentFastifyV3: ((options?: unknown) => FastifyInstrumentationV3) & {
     id: string;
 };
-export declare const instrumentFastify: ((options?: unknown) => Instrumentation<InstrumentationConfig>) & {
-    id: string;
-};
 /**
  * Adds Sentry tracing instrumentation for [Fastify](https://fastify.dev/).
  *
@@ -93,7 +92,9 @@ export declare const instrumentFastify: ((options?: unknown) => Instrumentation<
  * })
  * ```
  */
-export declare const fastifyIntegration: (options?: Partial<FastifyIntegrationOptions> | undefined) => import("@sentry/core").Integration;
+export declare const fastifyIntegration: (options?: Partial<FastifyIntegrationOptions> | undefined) => Integration & {
+    name: string;
+};
 /**
  * Add an Fastify error handler to capture errors to Sentry.
  *
@@ -115,5 +116,4 @@ export declare const fastifyIntegration: (options?: Partial<FastifyIntegrationOp
  * ```
  */
 export declare function setupFastifyErrorHandler(fastify: FastifyMinimal, options?: Partial<FastifyHandlerOptions>): void;
-export {};
 //# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,15 +1,10 @@
-import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { FirebaseInstrumentationConfig } from './types';
+import { InstrumentationConfig, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { InstrumentationBase } from '@opentelemetry/instrumentation';
 /**
  * Instrumentation for Firebase services, specifically Firestore.
  */
-export declare class FirebaseInstrumentation extends InstrumentationBase<FirebaseInstrumentationConfig> {
-    constructor(config?: FirebaseInstrumentationConfig);
-    /**
-     * sets config
-     * @param config
-     */
-    setConfig(config?: FirebaseInstrumentationConfig): void;
+export declare class FirebaseInstrumentation extends InstrumentationBase<InstrumentationConfig> {
+    constructor(config?: InstrumentationConfig);
     /**
      *
      * @protected

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

@@ -1,20 +1,17 @@
-import { Tracer } from '@opentelemetry/api';
 import { InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { FirebaseInstrumentationConfig, FirestoreSettings } from '../types';
+import { FirestoreSettings } from '../types';
 type ShimmerWrap = (target: any, name: string, wrapper: (...args: any[]) => any) => void;
 type ShimmerUnwrap = (target: any, name: string) => void;
 /**
  *
- * @param tracer - Opentelemetry Tracer
  * @param firestoreSupportedVersions - supported version of firebase/firestore
  * @param wrap - reference to native instrumentation wrap function
  * @param unwrap - reference to native instrumentation wrap function
  */
-export declare function patchFirestore(tracer: Tracer, firestoreSupportedVersions: string[], wrap: ShimmerWrap, unwrap: ShimmerUnwrap, config: FirebaseInstrumentationConfig): InstrumentationNodeModuleDefinition;
+export declare function patchFirestore(firestoreSupportedVersions: string[], wrap: ShimmerWrap, unwrap: ShimmerUnwrap): InstrumentationNodeModuleDefinition;
 /**
  * Gets the server address and port attributes from the Firestore settings.
  * It's best effort to extract the address and port from the settings, especially for IPv6.
- * @param span - The span to set attributes on.
  * @param settings - The Firestore settings containing host information.
  */
 export declare function getPortAndAddress(settings: FirestoreSettings): {

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

@@ -1,23 +1,18 @@
-import { Tracer } from '@opentelemetry/api';
 import { InstrumentationBase } from '@opentelemetry/instrumentation';
 import { InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { FirebaseFunctions, FirebaseInstrumentationConfig, OverloadedParameters } from '../types';
+import { FirebaseFunctions, OverloadedParameters } from '../types';
 /**
  * Patches Firebase Functions v2 to add OpenTelemetry instrumentation
- * @param tracer - Opentelemetry Tracer
  * @param functionsSupportedVersions - supported versions of firebase-functions
  * @param wrap - reference to native instrumentation wrap function
  * @param unwrap - reference to native instrumentation unwrap function
- * @param config - Firebase instrumentation config
  */
-export declare function patchFunctions(tracer: Tracer, functionsSupportedVersions: string[], wrap: InstrumentationBase['_wrap'], unwrap: InstrumentationBase['_unwrap'], config: FirebaseInstrumentationConfig): InstrumentationNodeModuleDefinition;
+export declare function patchFunctions(functionsSupportedVersions: string[], wrap: InstrumentationBase['_wrap'], unwrap: InstrumentationBase['_unwrap']): InstrumentationNodeModuleDefinition;
 /**
  * Patches Cloud Functions for Firebase (v2) to add OpenTelemetry instrumentation
  *
- * @param tracer - Opentelemetry Tracer
- * @param functionsConfig - Firebase instrumentation config
  * @param triggerType - Type of trigger
  * @returns A function that patches the function
  */
-export declare function patchV2Functions<T extends FirebaseFunctions = FirebaseFunctions>(tracer: Tracer, functionsConfig: FirebaseInstrumentationConfig['functions'], triggerType: string): (original: T) => (...args: OverloadedParameters<T>) => ReturnType<T>;
+export declare function patchV2Functions<T extends FirebaseFunctions = FirebaseFunctions>(triggerType: string): (original: T) => (...args: OverloadedParameters<T>) => ReturnType<T>;
 //# sourceMappingURL=functions.d.ts.map

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

@@ -1,5 +1,3 @@
-import { Span } from '@opentelemetry/api';
-import { InstrumentationConfig } from '@opentelemetry/instrumentation';
 export interface FirebaseOptions {
     [key: string]: any;
     apiKey?: string;
@@ -70,24 +68,6 @@ export interface FirestoreSettings {
     experimentalAutoDetectLongPolling?: boolean;
     useFetchStreams?: boolean;
 }
-/**
- * Firebase Auto Instrumentation
- */
-export interface FirebaseInstrumentationConfig extends InstrumentationConfig {
-    firestoreSpanCreationHook?: FirestoreSpanCreationHook;
-    functions?: FunctionsConfig;
-}
-export interface FunctionsConfig {
-    requestHook?: RequestHook;
-    responseHook?: ResponseHook;
-    errorHook?: ErrorHook;
-}
-export type RequestHook = (span: Span) => void;
-export type ResponseHook = (span: Span, error?: unknown) => void;
-export type ErrorHook = (span: Span, error?: unknown) => Promise<void> | void;
-export interface FirestoreSpanCreationHook {
-    (span: Span): void;
-}
 export type GetDocsType<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> = (query: CollectionReference<AppModelType, DbModelType>) => Promise<QuerySnapshot<AppModelType, DbModelType>>;
 export type SetDocType<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> = ((reference: DocumentReference<AppModelType, DbModelType>, data: WithFieldValue<AppModelType>) => Promise<void>) & ((reference: DocumentReference<AppModelType, DbModelType>, data: PartialWithFieldValue<AppModelType>, options: SetOptions) => Promise<void>);
 export type AddDocType<AppModelType, DbModelType extends DocumentData> = (reference: CollectionReference<AppModelType, DbModelType>, data: WithFieldValue<AppModelType>) => Promise<DocumentReference<AppModelType, DbModelType>>;

package/build/types-ts3.8/integrations/tracing/{genericPool.d.ts → genericPool/index.d.ts}

@@ -1,4 +1,4 @@
-import { GenericPoolInstrumentation } from '@opentelemetry/instrumentation-generic-pool';
+import { GenericPoolInstrumentation } from './vendored/instrumentation';
 export declare const instrumentGenericPool: ((options?: unknown) => GenericPoolInstrumentation) & {
     id: string;
 };
@@ -16,5 +16,7 @@ export declare const instrumentGenericPool: ((options?: unknown) => GenericPoolI
  * });
  * ```
  */
-export declare const genericPoolIntegration: () => import("@sentry/core").Integration;
-//# sourceMappingURL=genericPool.d.ts.map
+export declare const genericPoolIntegration: () => import("@sentry/core").Integration & {
+    name: "GenericPool";
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/genericPool/vendored/generic-pool-types.d.ts

@@ -0,0 +1,5 @@
+export declare class Pool<T> {
+    acquire(priority?: number): PromiseLike<T>;
+    [key: string]: unknown;
+}
+//# sourceMappingURL=generic-pool-types.d.ts.map

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

@@ -0,0 +1,11 @@
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+export declare class GenericPoolInstrumentation extends InstrumentationBase {
+    private _isDisabled;
+    constructor(config?: InstrumentationConfig);
+    init(): InstrumentationNodeModuleDefinition[];
+    private _acquirePatcher;
+    private _poolWrapper;
+    private _acquireWithCallbacksPatcher;
+}
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -21,18 +21,19 @@ export declare const instrumentGoogleGenAI: ((options?: GoogleGenAIOptions | und
  *
  * ## Options
  *
- * - `recordInputs`: Whether to record prompt messages (default: respects `sendDefaultPii` client option)
- * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client option)
+ * - `recordInputs`: Whether to record prompt messages (default: follows `dataCollection.genAI.inputs`)
+ * - `recordOutputs`: Whether to record response text (default: follows `dataCollection.genAI.outputs`)
  *
  * ### Default Behavior
  *
  * By default, the integration will:
- * - Record inputs and outputs ONLY if `sendDefaultPii` is set to `true` in your Sentry client options
- * - Otherwise, inputs and outputs are NOT recorded unless explicitly enabled
+ * - 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
- * // Record inputs and outputs when sendDefaultPii is false
+ * // Always record inputs and outputs regardless of global dataCollection config
  * Sentry.init({
  *   integrations: [
  *     Sentry.googleGenAiIntegration({
@@ -42,9 +43,9 @@ export declare const instrumentGoogleGenAI: ((options?: GoogleGenAIOptions | und
  *   ],
  * });
  *
- * // Never record inputs/outputs regardless of sendDefaultPii
+ * // Never record inputs/outputs regardless of global dataCollection config
  * Sentry.init({
- *   sendDefaultPii: true,
+ *   dataCollection: { genAI: { inputs: true, outputs: true } },
  *   integrations: [
  *     Sentry.googleGenAiIntegration({
  *       recordInputs: false,
@@ -55,5 +56,7 @@ export declare const instrumentGoogleGenAI: ((options?: GoogleGenAIOptions | und
  * ```
  *
  */
-export declare const googleGenAIIntegration: (options?: GoogleGenAIOptions | undefined) => import("@sentry/core").Integration;
+export declare const googleGenAIIntegration: (options?: GoogleGenAIOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Google_GenAI";
+};
 //# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing/{graphql.d.ts → graphql/index.d.ts}

@@ -1,4 +1,4 @@
-import { GraphQLInstrumentation } from '@opentelemetry/instrumentation-graphql';
+import { GraphQLInstrumentation } from './vendored/instrumentation';
 interface GraphqlOptions {
     /**
      * Do not create spans for resolvers.
@@ -43,6 +43,8 @@ export declare const instrumentGraphql: ((options: GraphqlOptions) => GraphQLIns
  *  integrations: [Sentry.graphqlIntegration()],
  * });
  */
-export declare const graphqlIntegration: (options?: GraphqlOptions | undefined) => import("@sentry/core").Integration;
+export declare const graphqlIntegration: (options?: GraphqlOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Graphql";
+};
 export {};
-//# sourceMappingURL=graphql.d.ts.map
+//# sourceMappingURL=index.d.ts.map