@depup/sentry__node 10.44.0-depup.0

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

@@ -0,0 +1,72 @@
+import * as http from 'node:http';
+import { ExpressInstrumentation } from '@opentelemetry/instrumentation-express';
+export declare const instrumentExpress: ((options?: unknown) => 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;
+}
+/**
+ * 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 {};
+//# sourceMappingURL=express.d.ts.map

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

@@ -0,0 +1,119 @@
+import { Instrumentation, InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { FastifyMinimal, FastifyReply, FastifyRequest } from './types';
+import { FastifyInstrumentationV3 } from './v3/instrumentation';
+/**
+ * Options for the Fastify integration.
+ *
+ * `shouldHandleError` - 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.
+ *
+ * @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)
+     */
+    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)
+     *
+     * @example
+     *
+     *
+     * ```javascript
+     * setupFastifyErrorHandler(app, {
+     *   shouldHandleError(_error, _request, reply) {
+     *     return reply.statusCode >= 400;
+     *   },
+     * });
+     * ```
+     *
+     *
+     * If using TypeScript, you can cast the request and reply to get full type safety.
+     *
+     * ```typescript
+     * import type { FastifyRequest, FastifyReply } from 'fastify';
+     *
+     * setupFastifyErrorHandler(app, {
+     *   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;
+}
+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/).
+ *
+ * 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) => import("@sentry/core").Integration;
+/**
+ * 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;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,19 @@
+import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { FirebaseInstrumentationConfig } from './types';
+/**
+ * Instrumentation for Firebase services, specifically Firestore.
+ */
+export declare class FirebaseInstrumentation extends InstrumentationBase<FirebaseInstrumentationConfig> {
+    constructor(config?: FirebaseInstrumentationConfig);
+    /**
+     * sets config
+     * @param config
+     */
+    setConfig(config?: FirebaseInstrumentationConfig): void;
+    /**
+     *
+     * @protected
+     */
+    protected init(): InstrumentationNodeModuleDefinition | InstrumentationNodeModuleDefinition[] | void;
+}
+//# sourceMappingURL=firebaseInstrumentation.d.ts.map

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

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

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

@@ -0,0 +1,25 @@
+import { Tracer } from '@opentelemetry/api';
+import { InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { FirebaseInstrumentationConfig, 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;
+/**
+ * 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): {
+    address?: string;
+    port?: number;
+};
+export {};
+//# sourceMappingURL=firestore.d.ts.map

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

@@ -0,0 +1,23 @@
+import { Tracer } from '@opentelemetry/api';
+import { InstrumentationBase } from '@opentelemetry/instrumentation';
+import { InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
+import { FirebaseFunctions, FirebaseInstrumentationConfig, 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;
+/**
+ * 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>;
+//# sourceMappingURL=functions.d.ts.map

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

@@ -0,0 +1,120 @@
+import { Span } from '@opentelemetry/api';
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+export interface FirebaseOptions {
+    [key: string]: any;
+    apiKey?: string;
+    authDomain?: string;
+    databaseURL?: string;
+    projectId?: string;
+    storageBucket?: string;
+    messagingSenderId?: string;
+    appId?: string;
+    measurementId?: string;
+}
+export interface FirebaseApp {
+    name: string;
+    options: FirebaseOptions;
+    automaticDataCollectionEnabled: boolean;
+    delete(): Promise<void>;
+}
+export interface DocumentData {
+    [field: string]: any;
+}
+export type WithFieldValue<T> = T;
+export type PartialWithFieldValue<T> = Partial<T>;
+export interface SetOptions {
+    merge?: boolean;
+    mergeFields?: (string | number | symbol)[];
+}
+export interface DocumentReference<T = DocumentData, U extends DocumentData = DocumentData> {
+    id: string;
+    firestore: {
+        app: FirebaseApp;
+        settings: FirestoreSettings;
+        useEmulator: (host: string, port: number) => void;
+        toJSON: () => {
+            app: FirebaseApp;
+            settings: FirestoreSettings;
+        };
+    };
+    type: 'collection' | 'document' | string;
+    path: string;
+    parent: CollectionReference<T, U>;
+}
+export interface CollectionReference<T = DocumentData, U extends DocumentData = DocumentData> {
+    id: string;
+    firestore: {
+        app: FirebaseApp;
+        settings: FirestoreSettings;
+        useEmulator: (host: string, port: number) => void;
+        toJSON: () => {
+            app: FirebaseApp;
+            settings: FirestoreSettings;
+        };
+    };
+    type: string;
+    path: string;
+    parent: DocumentReference<T, U> | null;
+}
+export interface QuerySnapshot<T = DocumentData, U extends DocumentData = DocumentData> {
+    docs: Array<DocumentReference<T, U>>;
+    size: number;
+    empty: boolean;
+}
+export interface FirestoreSettings {
+    host?: string;
+    ssl?: boolean;
+    ignoreUndefinedProperties?: boolean;
+    cacheSizeBytes?: number;
+    experimentalForceLongPolling?: boolean;
+    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>>;
+export type DeleteDocType<AppModelType, DbModelType extends DocumentData> = (reference: DocumentReference<AppModelType, DbModelType>) => Promise<void>;
+export type OverloadedParameters<T> = T extends {
+    (...args: infer A1): unknown;
+    (...args: infer A2): unknown;
+} ? A1 | A2 : T extends (...args: infer A) => unknown ? A : unknown;
+/**
+ * A bare minimum of how Cloud Functions for Firebase (v2) are defined.
+ */
+export type FirebaseFunctions = ((handler: () => Promise<unknown> | unknown) => (...args: unknown[]) => Promise<unknown> | unknown) | ((documentOrOptions: string | string[] | Record<string, unknown>, handler: () => Promise<unknown> | unknown) => (...args: unknown[]) => Promise<unknown> | unknown);
+export type AvailableFirebaseFunctions = {
+    onRequest: FirebaseFunctions;
+    onCall: FirebaseFunctions;
+    onDocumentCreated: FirebaseFunctions;
+    onDocumentUpdated: FirebaseFunctions;
+    onDocumentDeleted: FirebaseFunctions;
+    onDocumentWritten: FirebaseFunctions;
+    onDocumentCreatedWithAuthContext: FirebaseFunctions;
+    onDocumentUpdatedWithAuthContext: FirebaseFunctions;
+    onDocumentDeletedWithAuthContext: FirebaseFunctions;
+    onDocumentWrittenWithAuthContext: FirebaseFunctions;
+    onSchedule: FirebaseFunctions;
+    onObjectFinalized: FirebaseFunctions;
+    onObjectArchived: FirebaseFunctions;
+    onObjectDeleted: FirebaseFunctions;
+    onObjectMetadataUpdated: FirebaseFunctions;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,20 @@
+import { GenericPoolInstrumentation } from '@opentelemetry/instrumentation-generic-pool';
+export declare const instrumentGenericPool: ((options?: unknown) => GenericPoolInstrumentation) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the [generic-pool](https://www.npmjs.com/package/generic-pool) library.
+ *
+ * For more information, see the [`genericPoolIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/genericpool/).
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *  integrations: [Sentry.genericPoolIntegration()],
+ * });
+ * ```
+ */
+export declare const genericPoolIntegration: () => import("@sentry/core").Integration;
+//# sourceMappingURL=genericPool.d.ts.map

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

@@ -0,0 +1,59 @@
+import { GoogleGenAIOptions } from '@sentry/core';
+export declare const instrumentGoogleGenAI: ((options?: GoogleGenAIOptions | undefined) => import("@opentelemetry/instrumentation").Instrumentation<import("@opentelemetry/instrumentation").InstrumentationConfig>) & {
+    id: string;
+};
+/**
+ * Adds Sentry tracing instrumentation for the Google Generative AI SDK.
+ *
+ * This integration is enabled by default.
+ *
+ * When configured, this integration automatically instruments Google GenAI 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.googleGenAiIntegration()],
+ * });
+ * ```
+ *
+ * ## Options
+ *
+ * - `recordInputs`: Whether to record prompt messages (default: respects `sendDefaultPii` client option)
+ * - `recordOutputs`: Whether to record response text (default: respects `sendDefaultPii` client 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
+ *
+ * @example
+ * ```javascript
+ * // Record inputs and outputs when sendDefaultPii is false
+ * Sentry.init({
+ *   integrations: [
+ *     Sentry.googleGenAiIntegration({
+ *       recordInputs: true,
+ *       recordOutputs: true
+ *     })
+ *   ],
+ * });
+ *
+ * // Never record inputs/outputs regardless of sendDefaultPii
+ * Sentry.init({
+ *   sendDefaultPii: true,
+ *   integrations: [
+ *     Sentry.googleGenAiIntegration({
+ *       recordInputs: false,
+ *       recordOutputs: false
+ *     })
+ *   ],
+ * });
+ * ```
+ *
+ */
+export declare const googleGenAIIntegration: (options?: GoogleGenAIOptions | undefined) => import("@sentry/core").Integration;
+//# sourceMappingURL=index.d.ts.map

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

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