@depup/sentry__server-utils 10.67.0-depup.0

package/build/types/vercel-ai/vercel-ai-dc-subscriber.d.ts

@@ -0,0 +1,72 @@
+import type { Span } from '@sentry/core';
+import type { TracingChannel } from 'node:diagnostics_channel';
+import { type StreamedModelCallResult } from './util';
+/** Drop the per-operation `callId` maps once the owning top-level operation settles (success or error). */
+export declare function clearOperationId(data: VercelAiChannelMessage): void;
+/**
+ * Drop the per-operation `callId` maps for a single id. The v6 orchestrion adapter uses this to clear a
+ * `streamText` operation only after its lazily-run model call settles — the operation's own span ends
+ * synchronously (when `streamText` returns) but the model call runs later as the stream is consumed, and
+ * it still needs the operation's `operationId`/`isStream` entry to name itself `ai.streamText.doStream`.
+ */
+export declare function clearOperationCallId(callId: string): void;
+/** The lifecycle event types the `ai:telemetry` channel can carry. */
+export type ChannelEventType = 'generateText' | 'streamText' | 'generateObject' | 'step' | 'languageModelCall' | 'executeTool' | 'embed' | 'embedMany' | 'rerank';
+/**
+ * The context object the AI SDK passes through one tracing-channel call. It is the same object
+ * identity across `start`/`end`/`asyncEnd`/`error`, and Node's `tracingChannel` attaches
+ * `result`/`error` to it as the traced promise settles.
+ */
+export interface VercelAiChannelMessage {
+    type: ChannelEventType;
+    event: Record<string, unknown>;
+    result?: unknown;
+    error?: unknown;
+}
+/**
+ * Platform-provided factory that returns a tracing channel for the given channel name. The factory
+ * is responsible for, when `start` fires, calling `transformStart(data)` and storing the returned
+ * span on `data._sentrySpan` so the subscriber's `asyncEnd`/`error` handlers can read it.
+ *
+ * Node passes `@sentry/opentelemetry/tracing-channel`, which uses `bindStore` to additionally make
+ * the span the active OTel context for the duration of the traced operation. That is what makes
+ * nested AI SDK operations (model calls, tool calls) become children of the enclosing span without
+ * any manual parent bookkeeping here.
+ */
+export type VercelAiTracingChannelFactory = <T extends object>(name: string) => TracingChannel<T, T>;
+/** Integration-level recording options, pinned at subscribe time so we never look the integration up per event. */
+export interface VercelAiChannelOptions {
+    recordInputs?: boolean;
+    recordOutputs?: boolean;
+    enableTruncation?: boolean;
+}
+/**
+ * Subscribe Sentry span handlers to the `ai` SDK's native telemetry tracing channel (`ai:telemetry`,
+ * available in `ai` >= 7) and emit fully-formed `gen_ai.*` spans directly — no OpenTelemetry span
+ * post-processing involved.
+ *
+ * The integration passes its options in directly (rather than us looking the integration up on every
+ * event); the global `dataCollection.genAI` default is still read from the client per event.
+ *
+ * Safe to always call: on `ai` versions that don't publish to the channel (e.g. < 7) nothing is
+ * ever emitted and this is inert, so there is no double-instrumentation against the OTel-based
+ * patcher. The integration's `setupOnce` guarantees this runs a single time.
+ */
+export declare function subscribeVercelAiTracingChannel(tracingChannel: VercelAiTracingChannelFactory, options?: VercelAiChannelOptions): void;
+/** Map the tapped stream aggregate onto the `languageModelCall` result shape `enrichSpanOnEnd` reads. */
+export declare function streamedResultToChannelResult(final: StreamedModelCallResult): Record<string, unknown>;
+/**
+ * Transform a channel `start` payload into the span that should be active for the operation. For
+ * `step` we deliberately don't open a span (model calls and tool calls are siblings under the
+ * invoke_agent span, matching the OTel-based output), so we reuse the active span and mark the
+ * payload to skip ending it.
+ */
+export declare function createSpanFromMessage(data: VercelAiChannelMessage, channelOptions: VercelAiChannelOptions): Span | undefined;
+/**
+ * Best-effort enrichment from the resolved value the AI SDK attaches to the channel context.
+ * Everything here is guarded: when a field is missing or the shape differs across `ai` versions,
+ * we simply don't set the attribute rather than emit a malformed span.
+ */
+export declare function enrichSpanOnEnd(span: Span, data: VercelAiChannelMessage, channelOptions: VercelAiChannelOptions): void;
+export declare function captureToolError(span: Span, data: VercelAiChannelMessage, error: unknown): void;
+//# sourceMappingURL=vercel-ai-dc-subscriber.d.ts.map

package/build/types/vercel-ai/vercel-ai-dc-subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel-ai-dc-subscriber.d.ts","sourceRoot":"","sources":["../../../src/vercel-ai/vercel-ai-dc-subscriber.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,IAAI,EAAkB,MAAM,cAAc,CAAC;AAmBzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,OAAO,EAAwC,KAAK,uBAAuB,EAA2B,MAAM,QAAQ,CAAC;AAyDrH,2GAA2G;AAC3G,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,sBAAsB,GAAG,IAAI,CAQnE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAIzD;AA0CD,sEAAsE;AACtE,MAAM,MAAM,gBAAgB,GACxB,cAAc,GACd,YAAY,GACZ,gBAAgB,GAChB,MAAM,GACN,mBAAmB,GACnB,aAAa,GACb,OAAO,GACP,WAAW,GACX,QAAQ,CAAC;AAEb;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,gBAAgB,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAErG,mHAAmH;AACnH,MAAM,WAAW,sBAAsB;IACrC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAC7C,cAAc,EAAE,6BAA6B,EAC7C,OAAO,GAAE,sBAA2B,GACnC,IAAI,CAgBN;AAwCD,yGAAyG;AACzG,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,uBAAuB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuBrG;AA4CD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,sBAAsB,EAC5B,cAAc,EAAE,sBAAsB,GACrC,IAAI,GAAG,SAAS,CAuDlB;AA6ED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,sBAAsB,EAC5B,cAAc,EAAE,sBAAsB,GACrC,IAAI,CAsFN;AAuED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,sBAAsB,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CA0B/F"}

package/build/types/vercel-ai/vercel-ai-orchestrion-subscriber.d.ts

@@ -0,0 +1,12 @@
+import { type VercelAiChannelOptions, type VercelAiTracingChannelFactory } from './vercel-ai-dc-subscriber';
+/**
+ * Subscribe the v6 orchestrion channel adapter. Safe to always call: inert on
+ * `ai` >= 7 (those channels are never published) and when orchestrion injection
+ * isn't active. Idempotent.
+ *
+ * `tracingChannel` is the platform-provided factory (the same one passed to
+ * `subscribeVercelAiTracingChannel`); `options` pins the recording settings at
+ * subscribe time so we never look the integration up per event.
+ */
+export declare function subscribeVercelAiOrchestrionChannels(tracingChannel: VercelAiTracingChannelFactory, options?: VercelAiChannelOptions): void;
+//# sourceMappingURL=vercel-ai-orchestrion-subscriber.d.ts.map

package/build/types/vercel-ai/vercel-ai-orchestrion-subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel-ai-orchestrion-subscriber.d.ts","sourceRoot":"","sources":["../../../src/vercel-ai/vercel-ai-orchestrion-subscriber.ts"],"names":[],"mappings":"AAaA,OAAO,EAQL,KAAK,sBAAsB,EAC3B,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAC;AA8GnC;;;;;;;;GAQG;AACH,wBAAgB,oCAAoC,CAClD,cAAc,EAAE,6BAA6B,EAC7C,OAAO,GAAE,sBAA2B,GACnC,IAAI,CA8DN"}

package/build/types-ts3.8/debug-build.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.
+ *
+ * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.
+ */
+export declare const DEBUG_BUILD: boolean;
+//# sourceMappingURL=debug-build.d.ts.map

package/build/types-ts3.8/graphql/graphql-dc-subscriber.d.ts

@@ -0,0 +1,94 @@
+import { TracingChannel } from 'node:diagnostics_channel';
+import { GraphqlDocumentNode } from './utils';
+export declare const GRAPHQL_DC_CHANNEL_PARSE = "graphql:parse";
+export declare const GRAPHQL_DC_CHANNEL_VALIDATE = "graphql:validate";
+export declare const GRAPHQL_DC_CHANNEL_EXECUTE = "graphql:execute";
+export declare const GRAPHQL_DC_CHANNEL_SUBSCRIBE = "graphql:subscribe";
+export declare const GRAPHQL_DC_CHANNEL_RESOLVE = "graphql:resolve";
+/** Context published on the sync-only `graphql:parse` channel. */
+export interface GraphqlParseData {
+    source: string | {
+        body?: string;
+    };
+    result?: GraphqlDocumentNode;
+    error?: unknown;
+}
+/** Context published on the sync-only `graphql:validate` channel. */
+export interface GraphqlValidateData {
+    document: GraphqlDocumentNode;
+    /** Validation errors returned by validation; an empty array means the document is valid. */
+    result?: ReadonlyArray<unknown>;
+    error?: unknown;
+}
+/**
+ * Context published on the `graphql:execute` and `graphql:subscribe` channels.
+ *
+ * `result` carries an `ExecutionResult` (or, for subscriptions, an async generator); GraphQL errors
+ * collected during execution surface on `result.errors` rather than as the channel's `error`
+ * lifecycle event, which only fires on an abrupt throw.
+ */
+export interface GraphqlOperationData {
+    document: GraphqlDocumentNode;
+    operationName?: string;
+    operationType?: string;
+    result?: unknown;
+    error?: unknown;
+}
+/**
+ * Context published on the per-field `graphql:resolve` channel.
+ *
+ * A resolver throw or rejection publishes the `error` lifecycle event here; the same failure also
+ * surfaces in the enclosing execution result.
+ */
+export interface GraphqlResolveData {
+    fieldName: string;
+    parentType: string;
+    fieldType: string;
+    fieldPath: string;
+    /** Whether the field is handled by graphql's default property resolver (vs. a user resolver). */
+    isDefaultResolver: boolean;
+    alias?: string;
+    args?: unknown;
+    result?: unknown;
+    error?: unknown;
+}
+/** Options controlling which graphql channels the subscriber emits spans for. */
+export interface GraphqlDiagnosticChannelsOptions {
+    /**
+     * Do not create spans for resolvers. Resolver spans are per-field and can be very high volume.
+     * Defaults to `true`.
+     */
+    ignoreResolveSpans?: boolean;
+    /**
+     * When resolver spans are enabled, do not create them for graphql's default property resolver
+     * (fields without a user-defined resolver), which are rarely interesting. Defaults to `true`.
+     */
+    ignoreTrivialResolveSpans?: boolean;
+    /**
+     * Rename the enclosing root span to include the operation name(s), e.g.
+     * `GET /graphql` -> `GET /graphql (query GetUser)`. Defaults to `true`.
+     */
+    useOperationNameForRootSpan?: boolean;
+}
+/**
+ * Platform-provided factory that creates a native tracing channel for the given name. The
+ * subscriber binds the span and its lifecycle onto the channel via `bindTracingChannelToSpan`,
+ * which propagates the active span through the runtime's async context.
+ *
+ * Node passes `node:diagnostics_channel`'s `tracingChannel` directly.
+ */
+export type GraphqlTracingChannelFactory = <T extends object>(name: string) => TracingChannel<T, T>;
+/**
+ * Subscribe Sentry span handlers to graphql's diagnostics-channel events
+ * (`graphql:parse`, `:validate`, `:execute`, `:subscribe`), published by graphql >= 17.0.0.
+ *
+ * On older graphql versions the channels are never published to, so the subscribers are inert —
+ * there is no double-instrumentation against the vendored OTel patcher, which is gated to `< 17`.
+ *
+ * The per-field `graphql:resolve` channel is only subscribed when `ignoreResolveSpans` is `false`:
+ * resolver spans are per-field and can be extremely high-volume, so they are off by default (matching
+ * the legacy OTel path). When enabled, `ignoreTrivialResolveSpans` (default `true`) additionally skips
+ * graphql's default property resolver.
+ */
+export declare function subscribeGraphqlDiagnosticChannels(tracingChannel: GraphqlTracingChannelFactory, options?: GraphqlDiagnosticChannelsOptions): void;
+//# sourceMappingURL=graphql-dc-subscriber.d.ts.map

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

@@ -0,0 +1,12 @@
+import { GraphqlDiagnosticChannelsOptions } from './graphql-dc-subscriber';
+/**
+ * Auto-instrument the [graphql](https://www.npmjs.com/package/graphql) library via its native
+ * `node:diagnostics_channel` tracing channels (graphql >= 17).
+ *
+ * On older graphql versions the channels are never published to, so this integration is inert and
+ * the vendored OTel instrumentation (gated to `< 17`) handles instrumentation instead.
+ */
+export declare const graphqlIntegration: (options?: GraphqlDiagnosticChannelsOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Graphql";
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,36 @@
+import { Span } from '@sentry/core';
+/** Minimal shape of a graphql-js lexer token, enough to locate literal spans for redaction. */
+interface GraphqlToken {
+    kind: string;
+    start: number;
+    end: number;
+    next?: GraphqlToken | null;
+}
+/** Minimal shape of a parsed graphql-js `DocumentNode`, enough to read its source and tokens. */
+export interface GraphqlDocumentNode {
+    loc?: {
+        startToken?: GraphqlToken;
+        source?: {
+            body?: string;
+        };
+    };
+}
+/**
+ * Rename the enclosing root span to include the operation name(s), e.g. `GET /graphql (query GetUser)`.
+ * Mirrors the legacy OTel `useOperationNameForRootSpan` behavior; `parseSpanDescription` reads the same
+ * `sentry.graphql.operation` attribute on the OTel export path.
+ */
+export declare function renameRootSpanWithOperation(span: Span, operationType: string, operationName?: string): void;
+/**
+ * Span name follows the GraphQL semantic conventions: `<operation.type> <operation.name>` when both
+ * are available, `<operation.type>` when only the type is, otherwise a static fallback.
+ */
+export declare function getOperationSpanName(operationType: string | undefined, operationName: string | undefined, fallbackName: string): string;
+/** Whether a graphql execution result carries GraphQL errors (returned on `result.errors`). */
+export declare function hasResultErrors(result: unknown): boolean;
+/**
+ * Returns the redacted document if `dataCollection.graphQL.document` is enabled, `undefined` otherwise.
+ */
+export declare function collectGraphqlDocument(document: GraphqlDocumentNode | undefined): string | undefined;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/build/types-ts3.8/index.d.ts

@@ -0,0 +1,23 @@
+/// <reference path="./node-diagnostics-channel.d.ts" />
+/**
+ * Server-only utilities shared across Sentry server SDKs.
+ *
+ * @module
+ */
+export { graphqlIntegration } from './graphql';
+export { mongooseIntegration, startMongooseLegacySpan } from './mongoose';
+export { MongooseLegacyCollection, StartMongooseLegacySpanOptions } from './mongoose';
+export { getV3CommandOperation, getV3SpanAttributes, getV4SpanAttributes, startMongoSpan, } from './mongodb/mongodb-span';
+export { MongodbNamespace, MongoV3Topology } from './mongodb/mongodb-span';
+export { mysql2Integration } from './mysql2';
+export { instrumentPrisma, prismaIntegration } from './prisma';
+export { PrismaInstrumentationConfig, PrismaOptions } from './prisma';
+export { redisIntegration, RedisDiagnosticChannelsOptions } from './redis';
+export { RedisDiagnosticChannelResponseHook } from './redis/redis-dc-subscriber';
+export { defaultDbStatementSerializer } from './redis/redis-statement-serializer';
+export { bindTracingChannelToSpan } from './tracing-channel';
+export { SentryTracingChannel, TracingChannelLifeCycleOptions, TracingChannelBindingHandle, TracingChannelPayloadWithSpan, } from './tracing-channel';
+export { vercelAiIntegration } from './vercel-ai';
+export { InstrumentationConfig } from './orchestrion';
+export { fastifyIntegration, handleFastifyError, instrumentFastify, } from './integrations/tracing-channel/fastify';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * EXPERIMENTAL: orchestrion-driven `amqplib` integration.
+ *
+ * Subscribes to the `orchestrion:amqplib:*` diagnostics_channels that the orchestrion code transform
+ * injects into `amqplib`'s channel/connection methods. Requires the orchestrion runtime hook or
+ * bundler plugin to be active.
+ */
+export declare const amqplibChannelIntegration: () => import("@sentry/core").Integration & {
+    name: "Amqplib";
+};
+//# sourceMappingURL=amqplib.d.ts.map

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

@@ -0,0 +1,10 @@
+import { AnthropicAiOptions } from '@sentry/core';
+/**
+ * EXPERIMENTAL — orchestrion-driven Anthropic integration. Subscribes to the `orchestrion:@anthropic-ai/sdk:*`
+ * diagnostics_channels injected into the SDK's chat (`messages`/`completions`/beta `messages`), `models`, and
+ * `messages.stream()` methods, so it requires the orchestrion runtime hook or bundler plugin.
+ */
+export declare const anthropicChannelIntegration: (options?: AnthropicAiOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Anthropic_AI";
+};
+//# sourceMappingURL=anthropic.d.ts.map

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

@@ -0,0 +1,43 @@
+interface Blob {
+}
+type Binary = Buffer | Uint8Array | Blob | string;
+export declare namespace SNS {
+    interface MessageAttributeValue {
+        DataType: string;
+        StringValue?: string;
+        BinaryValue?: Binary;
+    }
+    export type MessageAttributeMap = {
+        [key: string]: MessageAttributeValue;
+    };
+    export {};
+}
+export declare namespace SQS {
+    type StringList = string[];
+    type BinaryList = Binary[];
+    interface MessageAttributeValue {
+        StringValue?: string;
+        BinaryValue?: Binary;
+        StringListValues?: StringList;
+        BinaryListValues?: BinaryList;
+        DataType: string;
+    }
+    export type MessageBodyAttributeMap = {
+        [key: string]: MessageAttributeValue;
+    };
+    type MessageSystemAttributeMap = {
+        [key: string]: string;
+    };
+    export interface Message {
+        MessageId?: string;
+        ReceiptHandle?: string;
+        MD5OfBody?: string;
+        Body?: string;
+        Attributes?: MessageSystemAttributeMap;
+        MD5OfMessageAttributes?: string;
+        MessageAttributes?: MessageBodyAttributeMap;
+    }
+    export {};
+}
+export {};
+//# sourceMappingURL=aws-sdk.types.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * AWS-specific span constants used by the aws-sdk channel integration that are NOT covered by
+ * `@sentry/conventions/attributes` (attribute names that exist there are imported from there
+ * directly). These are either Sentry-specific (the span origin), attribute *values* (not keys), or
+ * obsolete OTel conventions with no `@sentry/conventions` export.
+ */
+/** The span origin every aws-sdk channel span carries, mirroring the uniform OTel `auto.otel.aws`. */
+export declare const AWS_SDK_ORIGIN = "auto.aws.orchestrion.aws_sdk";
+/** DynamoDB `db.system` value (an attribute value, not a key, so not covered by conventions). */
+export declare const DB_SYSTEM_VALUE_DYNAMODB = "dynamodb";
+export declare const ATTR_MESSAGING_DESTINATION_KIND = "messaging.destination_kind";
+export declare const MESSAGING_DESTINATION_KIND_VALUE_TOPIC = "topic";
+export declare const GEN_AI_OPERATION_NAME_VALUE_CHAT = "chat";
+export declare const GEN_AI_SYSTEM_VALUE_AWS_BEDROCK = "aws.bedrock";
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1,15 @@
+/**
+ * EXPERIMENTAL — orchestrion-driven aws-sdk (v3) integration.
+ *
+ * Subscribes to the `orchestrion:@smithy/smithy-client:send` (and equivalent) diagnostics_channel
+ * the orchestrion code transform injects into the AWS SDK's smithy `Client.prototype.send`, emitting
+ * spans identical to the OTel `@opentelemetry/instrumentation-aws-sdk` integration (with a distinct
+ * `auto.aws.orchestrion.aws_sdk` origin). Requires the orchestrion runtime hook or bundler plugin —
+ * wire it up via `experimentalUseDiagnosticsChannelInjection()`.
+ *
+ * @experimental
+ */
+export declare const awsChannelIntegration: () => import("@sentry/core").Integration & {
+    name: "Aws";
+};
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/aws-sdk/services/MessageAttributes.d.ts

@@ -0,0 +1,23 @@
+import { SerializedTraceData } from '@sentry/core';
+import { SNS, SQS } from '../aws-sdk.types';
+export declare const MAX_MESSAGE_ATTRIBUTES = 10;
+export interface AwsSdkContextObject {
+    [key: string]: {
+        StringValue?: string;
+        Value?: string;
+    };
+}
+/**
+ * Inject trace-propagation headers (from `getTraceData({ span })`) into an SQS/SNS message-attribute
+ * map, so the consumer can continue the trace. Respects the SQS 10-attribute quota. Mirrors the OTel
+ * integration's `injectPropagationContext`, but writes Sentry's `sentry-trace`/`baggage` instead of
+ * W3C headers. Callers pass the precomputed headers so batch sends serialize them only once.
+ */
+export declare function injectPropagationContext(attributesMap: SQS.MessageBodyAttributeMap | SNS.MessageAttributeMap | undefined, traceData: SerializedTraceData): SQS.MessageBodyAttributeMap | SNS.MessageAttributeMap;
+/** Read the propagation headers back off a received SQS message, if present. */
+export declare function extractPropagationHeaders(message: SQS.Message): {
+    sentryTrace?: string;
+    baggage?: string;
+} | undefined;
+export declare function addPropagationFieldsToAttributeNames(messageAttributeNames?: string[]): string[];
+//# sourceMappingURL=MessageAttributes.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/aws-sdk/services/ServiceExtension.d.ts

@@ -0,0 +1,9 @@
+import { Span } from '@sentry/core';
+import { NormalizedRequest, NormalizedResponse, RequestMetadata } from '../types';
+export { RequestMetadata };
+export interface ServiceExtension {
+    requestPreSpanHook: (request: NormalizedRequest) => RequestMetadata;
+    requestPostSpanHook?: (request: NormalizedRequest, span: Span) => void;
+    responseHook?: (response: NormalizedResponse, span: Span) => void;
+}
+//# sourceMappingURL=ServiceExtension.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/aws-sdk/services/ServicesExtensions.d.ts

@@ -0,0 +1,10 @@
+import { Span } from '@sentry/core';
+import { NormalizedRequest, NormalizedResponse, RequestMetadata } from '../types';
+import { ServiceExtension } from './ServiceExtension';
+export declare class ServicesExtensions implements ServiceExtension {
+    private _services;
+    requestPreSpanHook(request: NormalizedRequest): RequestMetadata;
+    requestPostSpanHook(request: NormalizedRequest, span: Span): void;
+    responseHook(response: NormalizedResponse, span: Span): void;
+}
+//# sourceMappingURL=ServicesExtensions.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/aws-sdk/services/bedrock-runtime.d.ts

@@ -0,0 +1,14 @@
+import { Span } from '@sentry/core';
+import { NormalizedRequest, NormalizedResponse } from '../types';
+import { RequestMetadata, ServiceExtension } from './ServiceExtension';
+export declare class BedrockRuntimeServiceExtension implements ServiceExtension {
+    requestPreSpanHook(request: NormalizedRequest): RequestMetadata;
+    responseHook(response: NormalizedResponse, span: Span): void;
+    private _requestPreSpanHookConverse;
+    private _requestPreSpanHookInvokeModel;
+    private _responseHookConverse;
+    private _responseHookConverseStream;
+    private _responseHookInvokeModel;
+    private _responseHookInvokeModelWithResponseStream;
+}
+//# sourceMappingURL=bedrock-runtime.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/aws-sdk/services/dynamodb.d.ts

@@ -0,0 +1,8 @@
+import { Span } from '@sentry/core';
+import { NormalizedRequest, NormalizedResponse } from '../types';
+import { RequestMetadata, ServiceExtension } from './ServiceExtension';
+export declare class DynamodbServiceExtension implements ServiceExtension {
+    requestPreSpanHook(normalizedRequest: NormalizedRequest): RequestMetadata;
+    responseHook(response: NormalizedResponse, span: Span): void;
+}
+//# sourceMappingURL=dynamodb.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/aws-sdk/services/index.d.ts

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

package/build/types-ts3.8/integrations/tracing-channel/aws-sdk/services/kinesis.d.ts

@@ -0,0 +1,6 @@
+import { NormalizedRequest } from '../types';
+import { RequestMetadata, ServiceExtension } from './ServiceExtension';
+export declare class KinesisServiceExtension implements ServiceExtension {
+    requestPreSpanHook(request: NormalizedRequest): RequestMetadata;
+}
+//# sourceMappingURL=kinesis.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/aws-sdk/services/lambda.d.ts

@@ -0,0 +1,9 @@
+import { Span } from '@sentry/core';
+import { NormalizedRequest, NormalizedResponse } from '../types';
+import { RequestMetadata, ServiceExtension } from './ServiceExtension';
+export declare class LambdaServiceExtension implements ServiceExtension {
+    requestPreSpanHook(request: NormalizedRequest): RequestMetadata;
+    requestPostSpanHook(request: NormalizedRequest, span: Span): void;
+    responseHook(response: NormalizedResponse, span: Span): void;
+}
+//# sourceMappingURL=lambda.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/aws-sdk/services/s3.d.ts

@@ -0,0 +1,6 @@
+import { NormalizedRequest } from '../types';
+import { RequestMetadata, ServiceExtension } from './ServiceExtension';
+export declare class S3ServiceExtension implements ServiceExtension {
+    requestPreSpanHook(request: NormalizedRequest): RequestMetadata;
+}
+//# sourceMappingURL=s3.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/aws-sdk/services/secretsmanager.d.ts

@@ -0,0 +1,8 @@
+import { Span } from '@sentry/core';
+import { NormalizedRequest, NormalizedResponse } from '../types';
+import { RequestMetadata, ServiceExtension } from './ServiceExtension';
+export declare class SecretsManagerServiceExtension implements ServiceExtension {
+    requestPreSpanHook(request: NormalizedRequest): RequestMetadata;
+    responseHook(response: NormalizedResponse, span: Span): void;
+}
+//# sourceMappingURL=secretsmanager.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/aws-sdk/services/sns.d.ts

@@ -0,0 +1,9 @@
+import { Span } from '@sentry/core';
+import { NormalizedRequest, NormalizedResponse } from '../types';
+import { RequestMetadata, ServiceExtension } from './ServiceExtension';
+export declare class SnsServiceExtension implements ServiceExtension {
+    requestPreSpanHook(request: NormalizedRequest): RequestMetadata;
+    requestPostSpanHook(request: NormalizedRequest, span: Span): void;
+    responseHook(response: NormalizedResponse, span: Span): void;
+}
+//# sourceMappingURL=sns.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/aws-sdk/services/sqs.d.ts

@@ -0,0 +1,9 @@
+import { Span } from '@sentry/core';
+import { NormalizedRequest, NormalizedResponse } from '../types';
+import { RequestMetadata, ServiceExtension } from './ServiceExtension';
+export declare class SqsServiceExtension implements ServiceExtension {
+    requestPreSpanHook(request: NormalizedRequest): RequestMetadata;
+    requestPostSpanHook(request: NormalizedRequest, span: Span): void;
+    responseHook(response: NormalizedResponse, span: Span): void;
+}
+//# sourceMappingURL=sqs.d.ts.map

package/build/types-ts3.8/integrations/tracing-channel/aws-sdk/services/stepfunctions.d.ts

@@ -0,0 +1,6 @@
+import { NormalizedRequest } from '../types';
+import { RequestMetadata, ServiceExtension } from './ServiceExtension';
+export declare class StepFunctionsServiceExtension implements ServiceExtension {
+    requestPreSpanHook(request: NormalizedRequest): RequestMetadata;
+}
+//# sourceMappingURL=stepfunctions.d.ts.map

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

@@ -0,0 +1,26 @@
+import { SpanKindValue } from '@sentry/core';
+export type CommandInput = Record<string, any>;
+/**
+ * These are normalized request and response. They organize the relevant data in one interface which
+ * can be processed in a uniform manner in the per-service hooks.
+ */
+export interface NormalizedRequest {
+    serviceName: string;
+    commandName: string;
+    commandInput: CommandInput;
+    region?: string;
+}
+export interface NormalizedResponse {
+    data: any;
+    request: NormalizedRequest;
+    requestId?: string;
+}
+/** Span metadata a per-service extension returns for the subscriber to build the span from. */
+export interface RequestMetadata {
+    isStream?: boolean;
+    spanAttributes?: Record<string, unknown>;
+    spanKind?: SpanKindValue;
+    spanName?: string;
+    spanOp?: string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,5 @@
+import { CommandInput, NormalizedRequest } from './types';
+export declare function removeSuffixFromStringIfExists(str: string, suffixToRemove: string): string;
+export declare function normalizeV3Request(serviceName: string, commandNameWithSuffix: string, commandInput: CommandInput, region: string | undefined): NormalizedRequest;
+export declare function extractAttributesFromNormalizedRequest(normalizedRequest: NormalizedRequest): Record<string, unknown>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * EXPERIMENTAL: orchestrion-driven `dataloader` integration.
+ *
+ * Subscribes to the `orchestrion:dataloader:*` diagnostics_channels that the orchestrion code
+ * transform injects into `dataloader`'s constructor and prototype methods. Requires the orchestrion
+ * runtime hook or bundler plugin to be active.
+ */
+export declare const dataloaderChannelIntegration: () => import("@sentry/core").Integration & {
+    name: "Dataloader";
+};
+//# sourceMappingURL=dataloader.d.ts.map

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

@@ -0,0 +1,18 @@
+import { ExpressIntegrationOptions } from './types';
+/**
+ * EXPERIMENTAL — orchestrion-driven Express integration.
+ *
+ * Subscribes to the `orchestrion:express:handle` (Express v4) and
+ * `orchestrion:router:handle` (Express v5, via the `router` package)
+ * diagnostics_channels that the orchestrion code transform injects into the
+ * routing layer's request handler (`Layer.prototype.handle_request` /
+ * `handleRequest`). One span is opened per layer invocation — producing the
+ * same spans as the OTel Express instrumentation.
+ *
+ * Requires the orchestrion runtime hook or bundler plugin to be active — wire
+ * that up via `experimentalUseDiagnosticsChannelInjection()`.
+ */
+export declare const expressChannelIntegration: (options?: ExpressIntegrationOptions | undefined) => import("@sentry/core").Integration & {
+    name: "Express";
+};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,4 @@
+import * as diagnosticsChannel from 'node:diagnostics_channel';
+import { ExpressIntegrationOptions } from './types';
+export declare function instrumentExpress(options: ExpressIntegrationOptions, tracingChannel: typeof diagnosticsChannel.tracingChannel): void;
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1,28 @@
+import { ExpressLayer, ExpressRequest } from './types';
+/** Record the path pattern a layer was registered with. */
+export declare function setLayerRegisteredPath(layer: ExpressLayer, path: string | undefined): void;
+/** Read the path pattern a layer was registered with, if any. */
+export declare function getLayerRegisteredPath(layer: ExpressLayer): string | undefined;
+/** Push a layer's registered path onto the request's chain. */
+export declare function pushLayerPath(req: ExpressRequest, path: string): void;
+/** Pop the most recently pushed layer path off the request's chain. */
+export declare function popLayerPath(req: ExpressRequest): void;
+/**
+ * The path pattern a `route`/`use` call registered, derived from its arguments.
+ * A leading string/RegExp/number path becomes the pattern (arrays are joined
+ * with `,`); a bare handler function yields `undefined`. Kept in sync with
+ * `@sentry/core`'s Express `getLayerPath`.
+ */
+export declare function getLayerPath(args: unknown[]): string | undefined;
+/**
+ * Concatenate the stored layer paths into the full route pattern (parameters
+ * preserved), e.g. `/api/:version/user`. Mirrors `@sentry/core`.
+ */
+export declare function getConstructedRoute(req: ExpressRequest): string;
+/**
+ * Validate the constructed route against the request URL, returning it only
+ * when it plausibly corresponds to a real match (otherwise `undefined`). Mirrors
+ * `@sentry/core`'s `getActualMatchedRoute` — used for the `http.route` attribute.
+ */
+export declare function getActualMatchedRoute(req: ExpressRequest, constructedRoute: string): string | undefined;
+//# sourceMappingURL=route.d.ts.map