@depup/sentry__server-utils 10.67.0-depup.0

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

@@ -0,0 +1,64 @@
+export type ExpressLayerType = 'router' | 'middleware' | 'request_handler';
+/**
+ * The subset of an Express routing `Layer` we read at handle time. `handle` is
+ * the user's middleware/handler; `route` is only set on route-dispatch layers
+ * (and carries the parameterized path).
+ */
+export interface ExpressLayer {
+    handle?: {
+        length?: number;
+    };
+    name?: string;
+    path?: string;
+    route?: {
+        path?: unknown;
+    };
+    method?: string;
+}
+/** Minimal Express request/response shapes — avoids a hard dep on `node:http`. */
+export interface ExpressRequest {
+    method?: string;
+    baseUrl?: string;
+    originalUrl?: string;
+}
+export interface ExpressResponse {
+    once(event: string, listener: () => void): unknown;
+    removeListener(event: string, listener: () => void): unknown;
+}
+/**
+ * The shape orchestrion's transform attaches to the tracing-channel `context`
+ * object for `Layer.prototype.handle_request`/`handleRequest`: `self` is the
+ * Layer the method was invoked on and `arguments` are `[req, res, next]`.
+ *
+ * `_sentryCleanup` is ours: a teardown for the `res.on('finish')` listener we
+ * register, invoked from `beforeSpanEnd` when the span ends via `next()`.
+ * `_sentryStoredLayer` marks that this invocation pushed a layer path (so the
+ * matching pop on `asyncStart` stays symmetric).
+ */
+export interface HandleChannelContext {
+    self?: ExpressLayer;
+    arguments?: unknown[];
+    _sentryCleanup?: () => void;
+    _sentryStoredLayer?: boolean;
+}
+/**
+ * The context orchestrion attaches to the `route`/`use` registration channels:
+ * `self` is the router the method was invoked on (its freshly-pushed layer is
+ * the last entry in `stack`) and `arguments` are the registration args (the
+ * first of which is the path pattern).
+ */
+export interface RegistrationChannelContext {
+    self?: {
+        stack?: ExpressLayer[];
+    };
+    arguments?: unknown[];
+}
+type IgnoreMatcher = string | RegExp | ((name: string) => boolean);
+export interface ExpressIntegrationOptions {
+    /** Ignore specific based on their name */
+    ignoreLayers?: IgnoreMatcher[];
+    /** Ignore specific layers based on their type */
+    ignoreLayersType?: ExpressLayerType[];
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,12 @@
+import { FastifyReply, FastifyRequest } from './types';
+/**
+ * Subscribe to the Fastify v5 error diagnostics channel.
+ */
+export declare function subscribeToFastifyErrorChannel(): void;
+/**
+ * Handle a Fastify error, and possibly send it to Sentry.
+ */
+export declare function handleFastifyError(this: {
+    diagnosticsChannelExists?: boolean;
+}, error: Error, request: FastifyRequest, reply: FastifyReply, handlerOrigin: 'diagnostics-channel' | 'onError-hook'): void;
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1,66 @@
+import { FastifyReply, FastifyRequest } from './types';
+import { handleFastifyError as _handleFastifyError } from './errors';
+/**
+ * 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;
+}
+/**
+ * Adds Sentry tracing instrumentation for [Fastify](https://fastify.dev/).
+ * This integration supports Fastify v5 only.
+ *
+ * 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 & {
+    name: string;
+};
+/**
+ * @deprecated This export is deprecated and will not longer be exposed in the next major version.
+ */
+export declare const instrumentFastify: (() => void) & {
+    id: string;
+};
+/**
+ * @deprecated This export is deprecated and will not longer be exposed in the next major version.
+ */
+export declare const handleFastifyError: typeof _handleFastifyError;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,10 @@
+/**
+ * Set up the Fastify (>= 3.21.0 < 6) instrumentation by subscribing to the `fastify.initialization`
+ * diagnostics channel and registering the span-creating plugin on every Fastify instance.
+ *
+ * Idempotent and exposes an `id` so it can participate in the OpenTelemetry preload list.
+ */
+export declare const instrumentFastify: (() => void) & {
+    id: string;
+};
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1,32 @@
+import { Integration } from '@sentry/core';
+type HandlerOriginal = ((request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction) => Promise<void>) | ((request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction) => void);
+type FastifyError = any;
+type HookHandlerDoneFunction = <TError extends Error = FastifyError>(err?: TError) => void;
+export interface FastifyInstance {
+    version: string;
+    register: (plugin: any) => FastifyInstance;
+    decorate: (key: string | symbol, value: unknown) => void;
+    decorateRequest: (key: string | symbol, value: unknown) => void;
+    setNotFoundHandler: (hooks: any, handler?: any) => void;
+    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;
+}
+export interface FastifyReply {
+    send: () => FastifyReply;
+    statusCode: number;
+}
+export interface FastifyRequest {
+    method?: string;
+    routeOptions?: {
+        url?: string;
+    };
+    routerPath?: string;
+}
+export interface FastifyIntegration extends Integration {
+    getShouldHandleError: () => (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean;
+    setShouldHandleError: (shouldHandleError: (error: Error, request: FastifyRequest, reply: FastifyReply) => boolean) => void;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,9 @@
+import { FastifyReply, FastifyRequest } from './types';
+export declare const INTEGRATION_NAME = "Fastify";
+/**
+ * Default function to determine if an error should be sent to Sentry
+ *
+ * 3xx and 4xx errors are not sent by default.
+ */
+export declare function defaultShouldHandleError(_error: Error, _request: FastifyRequest, reply: FastifyReply): boolean;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1,10 @@
+/**
+ * EXPERIMENTAL — orchestrion-driven generic-pool integration. Subscribes to
+ * `orchestrion:generic-pool:acquire` (injected into `generic-pool/lib/Pool.js`'s
+ * `Pool.prototype.acquire`). Creates a `generic-pool.acquire` span for each
+ * acquisition. Requires the orchestrion runtime hook or bundler plugin.
+ */
+export declare const genericPoolChannelIntegration: () => import("@sentry/core").Integration & {
+    name: "GenericPool";
+};
+//# sourceMappingURL=generic-pool.d.ts.map

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

@@ -0,0 +1,12 @@
+import { GoogleGenAIOptions } from '@sentry/core';
+/**
+ * EXPERIMENTAL — orchestrion-driven Google GenAI integration. Subscribes to the
+ * `orchestrion:@google/genai:*` diagnostics_channels injected into the SDK's `Models`
+ * (`generateContent`/`generateContentStream`/`embedContent`) and `Chat`
+ * (`sendMessage`/`sendMessageStream`) methods, so it requires the orchestrion runtime hook or
+ * bundler plugin.
+ */
+export declare const googleGenAIChannelIntegration: (options?: GoogleGenAIOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Google_GenAI";
+};
+//# sourceMappingURL=google-genai.d.ts.map

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

@@ -0,0 +1,12 @@
+export declare const ORIGIN = "auto.graphql.diagnostic_channel";
+export declare const SPAN_NAME_PARSE = "graphql.parse";
+export declare const SPAN_NAME_VALIDATE = "graphql.validate";
+export declare const SPAN_NAME_EXECUTE = "graphql.execute";
+export declare const SPAN_NAME_RESOLVE = "graphql.resolve";
+export declare const GRAPHQL_FIELD_NAME = "graphql.field.name";
+export declare const GRAPHQL_FIELD_PATH = "graphql.field.path";
+export declare const GRAPHQL_FIELD_TYPE = "graphql.field.type";
+export declare const GRAPHQL_PARENT_NAME = "graphql.parent.name";
+export declare const GRAPHQL_DATA_SYMBOL: unique symbol;
+export declare const GRAPHQL_PATCHED_SYMBOL: unique symbol;
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1,135 @@
+export type PromiseOrValue<T> = T | Promise<T>;
+export type Maybe<T> = null | undefined | T;
+export interface Location {
+    start: number;
+    end: number;
+    startToken: Token;
+    [key: string]: unknown;
+}
+export interface Token {
+    kind: string;
+    start: number;
+    end: number;
+    line: number;
+    column: number;
+    value: string;
+    prev: Token | null;
+    next: Token | null;
+    [key: string]: unknown;
+}
+export interface Source {
+    body: string;
+    name: string;
+    [key: string]: unknown;
+}
+export interface DocumentNode {
+    kind: string;
+    definitions: ReadonlyArray<DefinitionNode>;
+    loc?: Location;
+    [key: string]: unknown;
+}
+export interface DefinitionNode {
+    kind: string;
+    operation?: string;
+    name?: {
+        kind: string;
+        value: string;
+        loc?: Location;
+    };
+    loc?: Location;
+    [key: string]: unknown;
+}
+export interface OperationDefinitionNode extends DefinitionNode {
+    operation: string;
+    name?: {
+        kind: string;
+        value: string;
+        loc?: Location;
+    };
+}
+export interface ParseOptions {
+    noLocation?: boolean;
+    [key: string]: unknown;
+}
+export interface ExecutionArgs {
+    schema: GraphQLSchema;
+    document: DocumentNode;
+    rootValue?: unknown;
+    contextValue?: unknown;
+    variableValues?: Maybe<Record<string, unknown>>;
+    operationName?: Maybe<string>;
+    fieldResolver?: Maybe<GraphQLFieldResolver>;
+    typeResolver?: Maybe<GraphQLTypeResolver>;
+    [key: string]: unknown;
+}
+export interface ExecutionResult {
+    errors?: ReadonlyArray<GraphQLError>;
+    data?: Record<string, unknown> | null;
+    [key: string]: unknown;
+}
+export interface GraphQLError {
+    message: string;
+    [key: string]: unknown;
+}
+export interface GraphQLSchema {
+    getQueryType(): GraphQLObjectType | undefined | null;
+    getMutationType(): GraphQLObjectType | undefined | null;
+    [key: string]: unknown;
+}
+export interface GraphQLObjectType {
+    name: string;
+    getFields(): Record<string, GraphQLField | undefined>;
+    [key: string]: unknown;
+}
+export interface GraphQLField {
+    name: string;
+    type: GraphQLOutputType;
+    resolve?: GraphQLFieldResolver;
+    [key: string]: unknown;
+}
+export type GraphQLOutputType = GraphQLNamedOutputType | GraphQLWrappingType;
+interface GraphQLNamedOutputType {
+    name?: string;
+    [key: string]: unknown;
+}
+interface GraphQLWrappingType {
+    ofType: GraphQLOutputType;
+    [key: string]: unknown;
+}
+export interface GraphQLUnionType {
+    name: string;
+    getTypes(): ReadonlyArray<GraphQLObjectType>;
+    [key: string]: unknown;
+}
+export type GraphQLType = GraphQLOutputType | GraphQLUnionType;
+export type GraphQLFieldResolver<TSource = unknown, TContext = unknown, TArgs = unknown> = (source: TSource, args: TArgs, context: TContext, info: GraphQLResolveInfo) => unknown;
+export type GraphQLTypeResolver<TSource = unknown, TContext = unknown> = (value: TSource, context: TContext, info: GraphQLResolveInfo, abstractType: unknown) => unknown;
+export interface GraphQLResolveInfo {
+    fieldName: string;
+    fieldNodes: ReadonlyArray<{
+        kind: string;
+        loc?: Location;
+        [key: string]: unknown;
+    }>;
+    returnType: {
+        toString(): string;
+        [key: string]: unknown;
+    };
+    parentType: {
+        name: string;
+        [key: string]: unknown;
+    };
+    path: GraphQLPath;
+    [key: string]: unknown;
+}
+export interface GraphQLPath {
+    prev: GraphQLPath | undefined;
+    key: string | number;
+    typename?: string | undefined;
+}
+export type ValidationRule = unknown;
+export interface TypeInfo {
+    [key: string]: unknown;
+}
+export {};
+//# sourceMappingURL=graphql-types.d.ts.map

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

@@ -0,0 +1,30 @@
+import { GraphqlDiagnosticChannelsOptions } from '../../../graphql/graphql-dc-subscriber';
+/**
+ * EXPERIMENTAL — orchestrion-driven graphql integration for graphql v14–16 (v17 publishes native
+ * `diagnostics_channel` events handled by `@sentry/server-utils`'s graphql integration instead).
+ *
+ * Subscribes to the `orchestrion:graphql:{parse,validate,execute}` channels the orchestrion code
+ * transform injects into `graphql`'s `language/parser.js`, `validation/validate.js` and
+ * `execution/execute.js`, emitting spans identical to the native path. Requires the orchestrion
+ * runtime hook or bundler plugin — wire it up via `experimentalUseDiagnosticsChannelInjection()`.
+ *
+ * @experimental
+ */
+export declare const graphqlChannelIntegration: (options?: GraphqlDiagnosticChannelsOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Graphql";
+};
+/**
+ * The complete graphql diagnostics-channel integration: the native subscriber (graphql v17) composed
+ * with the orchestrion subscriber (v14–16), so opting into injection instruments every supported
+ * version via diagnostics channels without the OTel patcher. Reuses the OTel `Graphql` name so
+ * enabling injection swaps this in for it.
+ */
+export declare const graphqlDiagnosticsChannelIntegration: (options?: GraphqlDiagnosticChannelsOptions) => Pick<import("@sentry/core").Integration & {
+    name: "Graphql";
+}, Exclude<keyof (import("@sentry/core").Integration & {
+    name: "Graphql";
+}), "name" | "setupOnce">> & {
+    name: "Graphql";
+    setupOnce: () => void | undefined;
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,13 @@
+import { DefinitionNode, DocumentNode, GraphQLFieldResolver, GraphQLObjectType, GraphqlResolvedConfig, Maybe, Patched } from './types';
+/**
+ * Walks the query/mutation type tree and swaps each field's `resolve` for a span-creating proxy.
+ * Idempotent per type via {@link GRAPHQL_PATCHED_SYMBOL}.
+ */
+export declare function wrapFields(type: Maybe<GraphQLObjectType & Patched>, getConfig: () => GraphqlResolvedConfig): void;
+export declare function wrapFieldResolver(getConfig: () => GraphqlResolvedConfig, fieldResolver: Maybe<GraphQLFieldResolver & Patched>, isDefaultResolver?: boolean): GraphQLFieldResolver & Patched;
+/**
+ * Returns the operation definition for `operationName` (or the first operation) from a parsed
+ * document, or `undefined` for schema documents / when no operation is present.
+ */
+export declare function getOperation(document: DocumentNode, operationName?: Maybe<string>): DefinitionNode | undefined;
+//# sourceMappingURL=resolvers.d.ts.map

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

@@ -0,0 +1,17 @@
+import { Span } from '@sentry/core';
+import { GraphqlResolvedConfig } from './types';
+export declare function startParseSpan(): Span;
+/** `documentAST` is the 2nd argument to `validate(schema, documentAST, …)`. */
+export declare function startValidateSpan(documentAST: unknown): Span;
+/** `result` is validation's return value: a (possibly empty) array of errors. */
+export declare function finalizeValidateSpan(span: Span, result: unknown): void;
+/**
+ * Opens the execute span and, unless resolver spans are disabled, swaps the schema's field resolvers
+ * (and the default field resolver) for span-creating proxies — mutating the live `arguments` in place
+ * so the wrapped `execute` call runs with them. Always returns a span; the caller guards against
+ * throws (see `safe` in `index.ts`).
+ */
+export declare function startExecuteSpan(argsArray: unknown[], self: unknown, config: GraphqlResolvedConfig, getConfig: () => GraphqlResolvedConfig): Span;
+/** `result` is the settled `ExecutionResult`; GraphQL errors surface on `result.errors`, not a throw. */
+export declare function finalizeExecuteSpan(span: Span, result: unknown): void;
+//# sourceMappingURL=spans.d.ts.map

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

@@ -0,0 +1,25 @@
+import { Span } from '@sentry/core';
+import { GRAPHQL_DATA_SYMBOL, GRAPHQL_PATCHED_SYMBOL } from './constants';
+import { DocumentNode } from './graphql-types';
+export * from './graphql-types';
+/** Bookkeeping we attach to `contextValue` to parent resolver spans under the execute span. */
+interface GraphQLSpanData {
+    source?: DocumentNode;
+    span: Span;
+    fields: Record<string, {
+        span: Span;
+    } | undefined>;
+}
+export interface ObjectWithGraphQLData {
+    [GRAPHQL_DATA_SYMBOL]?: GraphQLSpanData;
+}
+export interface Patched {
+    [GRAPHQL_PATCHED_SYMBOL]?: boolean;
+}
+/** Resolved integration config (defaults applied), shared by the span + resolver builders. */
+export interface GraphqlResolvedConfig {
+    ignoreResolveSpans: boolean;
+    ignoreTrivialResolveSpans: boolean;
+    useOperationNameForRootSpan: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,65 @@
+declare const LIFECYCLE_EXT_POINTS: readonly [
+    "onPreAuth",
+    "onCredentials",
+    "onPostAuth",
+    "onPreHandler",
+    "onPostHandler",
+    "onPreResponse",
+    "onRequest"
+];
+export type ServerRequestExtType = (typeof LIFECYCLE_EXT_POINTS)[number];
+export type LifecycleMethod = (request: unknown, h: unknown, err?: Error) => unknown;
+export interface ServerRouteOptions {
+    handler?: LifecycleMethod | unknown;
+    [key: string]: unknown;
+}
+export interface ServerRoute {
+    path: string;
+    method: string;
+    handler?: LifecycleMethod | unknown;
+    options?: ((server: unknown) => ServerRouteOptions) | ServerRouteOptions;
+    [key: string]: unknown;
+}
+export interface ServerExtEventsObject {
+    type: string;
+    [key: string]: unknown;
+}
+export interface ServerExtEventsRequestObject {
+    type: ServerRequestExtType;
+    method: LifecycleMethod;
+    [key: string]: unknown;
+}
+export interface ServerExtOptions {
+    [key: string]: unknown;
+}
+/**
+ * This symbol is used to mark a Hapi route handler or server extension handler as
+ * already patched, since it's possible to use these handlers multiple times
+ * i.e. when allowing multiple versions of one plugin, or when registering a plugin
+ * multiple times on different servers.
+ */
+export declare const handlerPatched: unique symbol;
+export type PatchableServerRoute = ServerRoute & {
+    [handlerPatched]?: boolean;
+};
+export type PatchableExtMethod = LifecycleMethod & {
+    [handlerPatched]?: boolean;
+};
+export type ServerExtDirectInput = [
+    ServerRequestExtType,
+    LifecycleMethod,
+    (ServerExtOptions | undefined)?
+];
+export declare const HapiLayerType: {
+    readonly ROUTER: "router";
+    readonly PLUGIN: "plugin";
+    readonly EXT: "server.ext";
+};
+export declare const HapiLifecycleMethodNames: Set<string>;
+export declare enum AttributeNames {
+    HAPI_TYPE = "hapi.type",
+    PLUGIN_NAME = "hapi.plugin.name",
+    EXT_TYPE = "server.ext.type"
+}
+export {};
+//# sourceMappingURL=hapi-types.d.ts.map

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

@@ -0,0 +1,25 @@
+import { ServerRequestExtType, ServerRoute } from './hapi-types';
+type SpanAttributes = Record<string, string | undefined>;
+interface SpanMetadata {
+    attributes: SpanAttributes;
+    name: string;
+}
+/** Build the span name and attributes for a Hapi route. */
+export declare const getRouteMetadata: (route: ServerRoute, pluginName?: string) => SpanMetadata;
+/** Build the span name and attributes for a Hapi server extension. */
+export declare const getExtMetadata: (extPoint: ServerRequestExtType, pluginName?: string, methodName?: string) => SpanMetadata;
+/**
+ * Wrap the route handler(s) in the live `server.route` arguments array, mutating
+ * `args[0]` in place. `args[0]` is either a single route options object or an
+ * array of them. Idempotent via the `handlerPatched` marker.
+ */
+export declare function wrapRouteArguments(args: unknown[], pluginName?: string): void;
+/**
+ * Wrap the extension method(s) in the live `server.ext` arguments array,
+ * mutating `args` in place. Handles the three accepted input shapes:
+ * `(eventsArray)`, `(lifecycleEventObject)`, and `(extTypeString, method, options)`.
+ * Idempotent via the `handlerPatched` marker.
+ */
+export declare function wrapExtArguments(args: unknown[], pluginName?: string): void;
+export {};
+//# sourceMappingURL=hapi-utils.d.ts.map

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

@@ -0,0 +1,9 @@
+/**
+ * EXPERIMENTAL — orchestrion-driven hapi integration. Subscribes to the
+ * `orchestrion:@hapi/hapi:route` / `:ext` channels injected into `@hapi/hapi`'s
+ * `lib/server.js`. Requires the orchestrion runtime hook or bundler plugin.
+ */
+export declare const hapiChannelIntegration: () => import("@sentry/core").Integration & {
+    name: "Hapi";
+};
+//# sourceMappingURL=hapi.d.ts.map

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

@@ -0,0 +1,37 @@
+import { Span } from '@sentry/core';
+/** Mirrors `@opentelemetry/instrumentation-ioredis`' response hook. Not called for failed commands. */
+export type IORedisResponseHook = (span: Span, command: string, args: Array<string | Buffer>, result: unknown) => void;
+export interface IORedisChannelIntegrationOptions {
+    responseHook?: IORedisResponseHook;
+}
+interface RedisClientLike {
+    options?: {
+        host?: string;
+        port?: number;
+    };
+}
+interface IORedisCommandContext {
+    arguments?: unknown[];
+    self?: RedisClientLike;
+    result?: unknown;
+    error?: unknown;
+}
+/**
+ * Builds the db span for an `orchestrion:ioredis:command` payload, or returns `undefined` to skip
+ * it: for a non-command payload, or the offline-queue re-send of an already-traced command.
+ *
+ * Exported for unit testing.
+ */
+export declare function startIORedisCommandSpan(data: IORedisCommandContext): Span | undefined;
+/**
+ * EXPERIMENTAL — orchestrion-driven ioredis integration. Subscribes to
+ * `orchestrion:ioredis:command` / `:connect` (injected into ioredis' `<5.11.0`
+ * `sendCommand`/`connect`) and creates db spans matching
+ * `@opentelemetry/instrumentation-ioredis`. Requires the orchestrion runtime hook
+ * or bundler plugin.
+ */
+export declare const ioredisChannelIntegration: (options?: IORedisChannelIntegrationOptions | undefined) => import("@sentry/core").Integration & {
+    name: "IORedis";
+};
+export {};
+//# sourceMappingURL=ioredis.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/kafkajs/consumer.d.ts

@@ -0,0 +1,8 @@
+import { EachBatchHandler, EachMessageHandler } from './types';
+/** Whether `fn` is a callback this module already wrapped, so callers skip re-wrapping it. */
+export declare function isWrappedConsumerCallback(fn: unknown): boolean;
+/** Wraps `eachMessage` so each processed message becomes a consumer span parented to the message's producer. */
+export declare function wrapEachMessage(original: EachMessageHandler): EachMessageHandler;
+/** Wraps `eachBatch` so the batch pull becomes a fresh-root receiving span with a process span per message. */
+export declare function wrapEachBatch(original: EachBatchHandler): EachBatchHandler;
+//# sourceMappingURL=consumer.d.ts.map

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

@@ -0,0 +1,17 @@
+/**
+ * EXPERIMENTAL — orchestrion-driven kafkajs integration.
+ *
+ * Subscribes to the `orchestrion:kafkajs:*` diagnostics_channels that the orchestrion code transform
+ * injects into `kafkajs`'s `producer/messageProducer.js` (`sendBatch`) and `consumer/index.js` (`run`).
+ * Requires the orchestrion runtime hook or bundler plugin to be active — wire that up via
+ * `experimentalUseDiagnosticsChannelInjection`.
+ *
+ * Known limitation vs. the OTel integration it replaces: the wrapping producer-`transaction` span is
+ * not emitted (the transformer can't replace `transaction()`'s return value to patch commit/abort).
+ * Transactional `send`/`sendBatch` calls still produce producer spans, since they route through the
+ * same instrumented `sendBatch`.
+ */
+export declare const kafkajsChannelIntegration: () => import("@sentry/core").Integration & {
+    name: "Kafka";
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/kafkajs/semconv.d.ts

@@ -0,0 +1,10 @@
+export declare const ATTR_MESSAGING_DESTINATION_PARTITION_ID: "messaging.destination.partition.id";
+export declare const ATTR_MESSAGING_KAFKA_MESSAGE_KEY: "messaging.kafka.message.key";
+export declare const ATTR_MESSAGING_KAFKA_MESSAGE_TOMBSTONE: "messaging.kafka.message.tombstone";
+export declare const ATTR_MESSAGING_KAFKA_OFFSET: "messaging.kafka.offset";
+export declare const MESSAGING_OPERATION_TYPE_VALUE_PROCESS: "process";
+export declare const MESSAGING_OPERATION_TYPE_VALUE_RECEIVE: "receive";
+export declare const MESSAGING_OPERATION_TYPE_VALUE_SEND: "send";
+export declare const MESSAGING_SYSTEM_VALUE_KAFKA: "kafka";
+export declare const ERROR_TYPE_VALUE_OTHER: "_OTHER";
+//# sourceMappingURL=semconv.d.ts.map