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

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

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

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

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

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

@@ -1,22 +0,0 @@
-import { InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { FirestoreSettings } from '../types';
-type ShimmerWrap = (target: any, name: string, wrapper: (...args: any[]) => any) => void;
-type ShimmerUnwrap = (target: any, name: string) => void;
-/**
- *
- * @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(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 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

@@ -1,18 +0,0 @@
-import { InstrumentationBase } from '@opentelemetry/instrumentation';
-import { InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { FirebaseFunctions, OverloadedParameters } from '../types';
-/**
- * Patches Firebase Functions v2 to add OpenTelemetry instrumentation
- * @param functionsSupportedVersions - supported versions of firebase-functions
- * @param wrap - reference to native instrumentation wrap function
- * @param unwrap - reference to native instrumentation unwrap function
- */
-export declare function patchFunctions(functionsSupportedVersions: string[], wrap: InstrumentationBase['_wrap'], unwrap: InstrumentationBase['_unwrap']): InstrumentationNodeModuleDefinition;
-/**
- * Patches Cloud Functions for Firebase (v2) to add OpenTelemetry instrumentation
- *
- * @param triggerType - Type of trigger
- * @returns A function that patches the function
- */
-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,100 +0,0 @@
-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;
-}
-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/index.d.ts

@@ -1,22 +0,0 @@
-import { GenericPoolInstrumentation } from './vendored/instrumentation';
-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 & {
-    name: "GenericPool";
-};
-//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -1,62 +0,0 @@
-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: 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 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.googleGenAiIntegration({
- *       recordInputs: true,
- *       recordOutputs: true
- *     })
- *   ],
- * });
- *
- * // Never record inputs/outputs regardless of global dataCollection config
- * Sentry.init({
- *   dataCollection: { genAI: { inputs: true, outputs: true } },
- *   integrations: [
- *     Sentry.googleGenAiIntegration({
- *       recordInputs: false,
- *       recordOutputs: false
- *     })
- *   ],
- * });
- * ```
- *
- */
-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/google-genai/instrumentation.d.ts

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

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

@@ -1,50 +0,0 @@
-import { GraphQLInstrumentation } from './vendored/instrumentation';
-interface GraphqlOptions {
-    /**
-     * Do not create spans for resolvers.
-     *
-     * Defaults to true.
-     */
-    ignoreResolveSpans?: boolean;
-    /**
-     * Don't create spans for the execution of the default resolver on object properties.
-     *
-     * When a resolver function is not defined on the schema for a field, graphql will
-     * use the default resolver which just looks for a property with that name on the object.
-     * If the property is not a function, it's not very interesting to trace.
-     * This option can reduce noise and number of spans created.
-     *
-     * Defaults to true.
-     */
-    ignoreTrivialResolveSpans?: boolean;
-    /**
-     * If this is enabled, a http.server root span containing this span will automatically be renamed to include the operation name.
-     * Set this to `false` if you do not want this behavior, and want to keep the default http.server span name.
-     *
-     * Defaults to true.
-     */
-    useOperationNameForRootSpan?: boolean;
-}
-export declare const instrumentGraphql: ((options: GraphqlOptions) => GraphQLInstrumentation) & {
-    id: string;
-};
-/**
- * Adds Sentry tracing instrumentation for the [graphql](https://www.npmjs.com/package/graphql) library.
- *
- * For more information, see the [`graphqlIntegration` documentation](https://docs.sentry.io/platforms/javascript/guides/node/configuration/integrations/graphql/).
- *
- * @param {GraphqlOptions} options Configuration options for the GraphQL integration.
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- *
- * Sentry.init({
- *  integrations: [Sentry.graphqlIntegration()],
- * });
- */
-export declare const graphqlIntegration: (options?: GraphqlOptions | undefined) => import("@sentry/core").Integration & {
-    name: "Graphql";
-};
-export {};
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,38 +0,0 @@
-export declare enum AllowedOperationTypes {
-    QUERY = "query",
-    MUTATION = "mutation",
-    SUBSCRIPTION = "subscription"
-}
-export declare enum TokenKind {
-    SOF = "<SOF>",
-    EOF = "<EOF>",
-    BANG = "!",
-    DOLLAR = "$",
-    AMP = "&",
-    PAREN_L = "(",
-    PAREN_R = ")",
-    SPREAD = "...",
-    COLON = ":",
-    EQUALS = "=",
-    AT = "@",
-    BRACKET_L = "[",
-    BRACKET_R = "]",
-    BRACE_L = "{",
-    PIPE = "|",
-    BRACE_R = "}",
-    NAME = "Name",
-    INT = "Int",
-    FLOAT = "Float",
-    STRING = "String",
-    BLOCK_STRING = "BlockString",
-    COMMENT = "Comment"
-}
-export declare enum SpanNames {
-    EXECUTE = "graphql.execute",
-    PARSE = "graphql.parse",
-    RESOLVE = "graphql.resolve",
-    VALIDATE = "graphql.validate",
-    SCHEMA_VALIDATE = "graphql.validateSchema",
-    SCHEMA_PARSE = "graphql.parseSchema"
-}
-//# sourceMappingURL=enum.d.ts.map

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

@@ -1,10 +0,0 @@
-export declare enum AttributeNames {
-    SOURCE = "graphql.source",
-    FIELD_NAME = "graphql.field.name",
-    FIELD_PATH = "graphql.field.path",
-    FIELD_TYPE = "graphql.field.type",
-    PARENT_NAME = "graphql.parent.name",
-    OPERATION_TYPE = "graphql.operation.type",
-    OPERATION_NAME = "graphql.operation.name"
-}
-//# sourceMappingURL=AttributeNames.d.ts.map

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

@@ -1,2 +0,0 @@
-export { DefinitionNode, DocumentNode, ExecutionArgs, ExecutionResult, GraphQLError, GraphQLFieldResolver, GraphQLObjectType, GraphQLOutputType, GraphQLResolveInfo, GraphQLSchema, GraphQLType, GraphQLTypeResolver, GraphQLUnionType, Location, Maybe, OperationDefinitionNode, ParseOptions, PromiseOrValue, Source, Token, TypeInfo, ValidationRule, } from '@sentry/server-utils/orchestrion';
-//# sourceMappingURL=graphql-types.d.ts.map

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

@@ -1,25 +0,0 @@
-import { InstrumentationBase, InstrumentationNodeModuleDefinition } from '@opentelemetry/instrumentation';
-import { GraphQLInstrumentationConfig, GraphQLInstrumentationParsedConfig } from './types';
-export declare class GraphQLInstrumentation extends InstrumentationBase<GraphQLInstrumentationParsedConfig> {
-    constructor(config?: GraphQLInstrumentationConfig);
-    setConfig(config?: GraphQLInstrumentationConfig): void;
-    protected init(): InstrumentationNodeModuleDefinition;
-    private _addPatchingExecute;
-    private _addPatchingParser;
-    private _addPatchingValidate;
-    private _patchExecute;
-    private _handleExecutionResult;
-    /**
-     * Applies Sentry-specific span mutations based on the GraphQL execution result:
-     * - Marks the execute span as errored if the result contains errors (and no status was set yet)
-     * - Optionally renames the containing root span to include the GraphQL operation name(s)
-     */
-    private _updateSpanFromResult;
-    private _patchParse;
-    private _patchValidate;
-    private _parse;
-    private _validate;
-    private _createExecuteSpan;
-    private _wrapExecuteArgs;
-}
-//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -1,63 +0,0 @@
-import { Span } from '@sentry/core';
-import { DocumentNode, ExecutionArgs, ExecutionResult, GraphQLError, GraphQLFieldResolver, GraphQLSchema, GraphQLTypeResolver, Maybe, ParseOptions, PromiseOrValue, Source, TypeInfo, ValidationRule } from './graphql-types';
-import { OTEL_GRAPHQL_DATA_SYMBOL, OTEL_PATCHED_SYMBOL } from './symbols';
-export { Maybe } from './graphql-types';
-export declare const OPERATION_NOT_SUPPORTED: string;
-export type executeFunctionWithObj = (args: ExecutionArgs) => PromiseOrValue<ExecutionResult>;
-export type executeArgumentsArray = [
-    GraphQLSchema,
-    DocumentNode,
-    any,
-    any,
-    Maybe<{
-        [key: string]: any;
-    }>,
-    Maybe<string>,
-    Maybe<GraphQLFieldResolver<any, any>>,
-    Maybe<GraphQLTypeResolver<any, any>>
-];
-export type executeFunctionWithArgs = (schema: GraphQLSchema, document: DocumentNode, rootValue?: any, contextValue?: any, variableValues?: Maybe<{
-    [key: string]: any;
-}>, operationName?: Maybe<string>, fieldResolver?: Maybe<GraphQLFieldResolver<any, any>>, typeResolver?: Maybe<GraphQLTypeResolver<any, any>>) => PromiseOrValue<ExecutionResult>;
-export interface OtelExecutionArgs {
-    schema: GraphQLSchema;
-    document: DocumentNode & ObjectWithGraphQLData;
-    rootValue?: any;
-    contextValue?: any & ObjectWithGraphQLData;
-    variableValues?: Maybe<{
-        [key: string]: any;
-    }>;
-    operationName?: Maybe<string>;
-    fieldResolver?: Maybe<GraphQLFieldResolver<any, any> & OtelPatched>;
-    typeResolver?: Maybe<GraphQLTypeResolver<any, any>>;
-}
-export type executeType = executeFunctionWithObj | executeFunctionWithArgs;
-export type parseType = (source: string | Source, options?: ParseOptions) => DocumentNode;
-export type validateType = (schema: GraphQLSchema, documentAST: DocumentNode, rules?: ReadonlyArray<ValidationRule>, options?: {
-    maxErrors?: number;
-}, typeInfo?: TypeInfo) => ReadonlyArray<GraphQLError>;
-export interface GraphQLField {
-    span: Span;
-}
-interface OtelGraphQLData {
-    source?: any;
-    span: Span;
-    fields: {
-        [key: string]: GraphQLField;
-    };
-}
-export interface ObjectWithGraphQLData {
-    [OTEL_GRAPHQL_DATA_SYMBOL]?: OtelGraphQLData;
-}
-export interface OtelPatched {
-    [OTEL_PATCHED_SYMBOL]?: boolean;
-}
-export interface GraphQLPath {
-    prev: GraphQLPath | undefined;
-    key: string | number;
-    /**
-     * optional as it didn't exist yet in ver 14
-     */
-    typename?: string | undefined;
-}
-//# sourceMappingURL=internal-types.d.ts.map

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

@@ -1,3 +0,0 @@
-export declare const OTEL_PATCHED_SYMBOL: unique symbol;
-export declare const OTEL_GRAPHQL_DATA_SYMBOL: unique symbol;
-//# sourceMappingURL=symbols.d.ts.map

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

@@ -1,33 +0,0 @@
-import { InstrumentationConfig } from '@opentelemetry/instrumentation';
-export interface GraphQLInstrumentationConfig extends InstrumentationConfig {
-    /**
-     * Do not create spans for resolvers.
-     *
-     * @default false
-     */
-    ignoreResolveSpans?: boolean;
-    /**
-     * Don't create spans for the execution of the default resolver on object properties.
-     *
-     * When a resolver function is not defined on the schema for a field, graphql will
-     * use the default resolver which just looks for a property with that name on the object.
-     * If the property is not a function, it's not very interesting to trace.
-     * This option can reduce noise and number of spans created.
-     *
-     * @default false
-     */
-    ignoreTrivialResolveSpans?: boolean;
-    /**
-     * If this is enabled, a `http.server` root span containing the execute span will automatically be renamed
-     * to include the operation name.
-     *
-     * @default false
-     */
-    useOperationNameForRootSpan?: boolean;
-}
-type RequireSpecificKeys<T, K extends keyof T> = T & {
-    [P in K]-?: T[P];
-};
-export type GraphQLInstrumentationParsedConfig = RequireSpecificKeys<GraphQLInstrumentationConfig, 'ignoreResolveSpans'>;
-export {};
-//# sourceMappingURL=types.d.ts.map

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

@@ -1,14 +0,0 @@
-import { DocumentNode, GraphQLFieldResolver, GraphQLObjectType, Location, Maybe } from './graphql-types';
-import { Span } from '@sentry/core';
-import { ObjectWithGraphQLData, OtelPatched } from './internal-types';
-import { GraphQLInstrumentationParsedConfig } from './types';
-export declare const isPromise: (value: any) => value is Promise<unknown>;
-export declare function addSpanSource(span: Span, loc?: Location, start?: number, end?: number): void;
-export declare function endSpan(span: Span, error?: Error): void;
-export declare function getOperation(document: DocumentNode, operationName?: Maybe<string>): DefinitionNodeLike | undefined;
-type DefinitionNodeLike = DocumentNode['definitions'][number];
-export declare function getSourceFromLocation(loc?: Location, inputStart?: number, inputEnd?: number): string;
-export declare function wrapFields(type: Maybe<GraphQLObjectType & OtelPatched>, getConfig: () => GraphQLInstrumentationParsedConfig): void;
-export declare function wrapFieldResolver<TSource = any, TContext = any, TArgs = any>(getConfig: () => GraphQLInstrumentationParsedConfig, fieldResolver: Maybe<GraphQLFieldResolver<TSource, TContext, TArgs> & OtelPatched>, isDefaultResolver?: boolean): GraphQLFieldResolver<TSource, TContext & ObjectWithGraphQLData, TArgs> & OtelPatched;
-export {};
-//# sourceMappingURL=utils.d.ts.map

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

@@ -1,52 +0,0 @@
-import { HapiInstrumentation } from './vendored/instrumentation';
-import { Server } from './types';
-export declare const instrumentHapi: ((options?: unknown) => HapiInstrumentation) & {
-    id: string;
-};
-/**
- * Adds Sentry tracing instrumentation for [Hapi](https://hapi.dev/).
- *
- * If you also want to capture errors, you need to call `setupHapiErrorHandler(server)` after you set up your server.
- *
- * For more information, see the [hapi documentation](https://docs.sentry.io/platforms/javascript/guides/hapi/).
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- *
- * Sentry.init({
- *   integrations: [Sentry.hapiIntegration()],
- * })
- * ```
- */
-export declare const hapiIntegration: () => import("@sentry/core").Integration & {
-    name: "Hapi";
-};
-export declare const hapiErrorPlugin: {
-    name: string;
-    version: string;
-    register: (serverArg: Record<any, any>) => Promise<void>;
-};
-/**
- * Add a Hapi plugin to capture errors to Sentry.
- *
- * @param server The Hapi server to attach the error handler to
- *
- * @example
- * ```javascript
- * const Sentry = require('@sentry/node');
- * const Hapi = require('@hapi/hapi');
- *
- * const init = async () => {
- *   const server = Hapi.server();
- *
- *   // all your routes here
- *
- *   await Sentry.setupHapiErrorHandler(server);
- *
- *   await server.start();
- * };
- * ```
- */
-export declare function setupHapiErrorHandler(server: Server): Promise<void>;
-//# sourceMappingURL=index.d.ts.map