@sentry/browser 10.70.0 → 11.0.0-alpha.1

package/build/npm/types-ts3.8/profiling/utils.d.ts

@@ -1,112 +0,0 @@
-import { Client, DebugImage, Envelope, Event, EventEnvelope, Profile, ProfileChunk, Span, ThreadCpuProfile } from '@sentry/core/browser';
-import { BrowserOptions } from '../client';
-import { JSSelfProfile, JSSelfProfiler } from './jsSelfProfiling';
-export declare const PROFILER_THREAD_ID_STRING: string;
-export declare const PROFILER_THREAD_NAME: string;
-/**
- *
- */
-export declare function enrichWithThreadInformation(profile: ThreadCpuProfile | JSSelfProfile): ThreadCpuProfile;
-export interface ProfiledEvent extends Event {
-    sdkProcessingMetadata: {
-        profile?: JSSelfProfile;
-    };
-}
-/**
- * Creates a profiling event envelope from a Sentry event. If profile does not pass
- * validation, returns null.
- * @param event
- * @param dsn
- * @param metadata
- * @param tunnel
- * @returns {EventEnvelope | null}
- */
-/**
- * Creates a profiling event envelope from a Sentry event.
- */
-export declare function createProfilePayload(profile_id: string, start_timestamp: number | undefined, processed_profile: JSSelfProfile, event: ProfiledEvent): Profile;
-/**
- * Create a profile chunk envelope item
- */
-export declare function createProfileChunkPayload(jsSelfProfile: JSSelfProfile, client: Client, profilerId?: string): ProfileChunk;
-/**
- * Validate a profile chunk against the Sample Format V2 requirements.
- * https://develop.sentry.dev/sdk/telemetry/profiles/sample-format-v2/
- * - Presence of samples, stacks, frames
- * - Required metadata fields
- */
-export declare function validateProfileChunk(chunk: ProfileChunk): {
-    valid: true;
-} | {
-    reason: string;
-};
-/**
- *
- */
-export declare function isProfiledTransactionEvent(event: Event): event is ProfiledEvent;
-/**
- *
- */
-export declare function isAutomatedPageLoadSpan(span: Span): boolean;
-/**
- * Converts a JSSelfProfile to a our sampled format.
- * Does not currently perform stack indexing.
- */
-export declare function convertJSSelfProfileToSampledFormat(input: JSSelfProfile): Profile['profile'];
-/**
- * Adds items to envelope if they are not already present - mutates the envelope.
- * @param envelope
- */
-export declare function addProfilesToEnvelope(envelope: EventEnvelope, profiles: Profile[]): Envelope;
-/**
- * Finds transactions with profile_id context in the envelope
- * @param envelope
- * @returns
- */
-export declare function findProfiledTransactionsFromEnvelope(envelope: Envelope): Event[];
-/**
- * Applies debug meta data to an event from a list of paths to resources (sourcemaps)
- */
-export declare function applyDebugMetadata(resource_paths: ReadonlyArray<string>): DebugImage[];
-/**
- * Checks the given sample rate to make sure it is valid type and value (a boolean, or a number between 0 and 1).
- */
-export declare function isValidSampleRate(rate: unknown): boolean;
-export declare const MAX_PROFILE_DURATION_MS = 30000;
-/**
- * Starts the profiler and returns the profiler instance.
- */
-export declare function startJSSelfProfile(): JSSelfProfiler | undefined;
-/**
- * Determine if a profile should be profiled.
- */
-export declare function shouldProfileSpanLegacy(span: Span): boolean;
-/**
- * Determine if a profile should be created for the current session.
- */
-export declare function shouldProfileSession(options: BrowserOptions): boolean;
-/**
- * Checks if legacy profiling is configured.
- */
-export declare function hasLegacyProfiling(options: BrowserOptions): boolean;
-/**
- * Creates a profiling envelope item, if the profile does not pass validation, returns null.
- * @param event
- * @returns {Profile | null}
- */
-export declare function createProfilingEvent(profile_id: string, start_timestamp: number | undefined, profile: JSSelfProfile, event: ProfiledEvent): Profile | null;
-/**
- *
- */
-export declare function getActiveProfilesCount(): number;
-/**
- * Retrieves profile from global cache and removes it.
- */
-export declare function takeProfileFromGlobalCache(profile_id: string): JSSelfProfile | undefined;
-/**
- * Adds profile to global cache and evicts the oldest profile if the cache is full.
- */
-export declare function addProfileToGlobalCache(profile_id: string, profile: JSSelfProfile): void;
-export declare const PROFILED_ROOT_SPANS: WeakSet<Span>;
-export declare function setThreadAttributes(span: Span): void;
-//# sourceMappingURL=utils.d.ts.map

package/build/npm/types-ts3.8/report-dialog.d.ts

@@ -1,8 +0,0 @@
-import { ReportDialogOptions } from '@sentry/core/browser';
-/**
- * Present the user with a report dialog.
- *
- * @param options Everything is optional, we try to fetch all info need from the current scope.
- */
-export declare function showReportDialog(options?: ReportDialogOptions): void;
-//# sourceMappingURL=report-dialog.d.ts.map

package/build/npm/types-ts3.8/sdk.d.ts

@@ -1,62 +0,0 @@
-import { Client, Integration, Options } from '@sentry/core/browser';
-import { BrowserOptions } from './client';
-/** Get the default integrations for the browser SDK. */
-export declare function getDefaultIntegrations(_options: Options): Integration[];
-/**
- * The Sentry Browser SDK Client.
- *
- * To use this SDK, call the {@link init} function as early as possible when
- * loading the web page. To set context information or send manual events, use
- * the provided methods.
- *
- * @example
- *
- * ```
- *
- * import { init } from '@sentry/browser';
- *
- * init({
- *   dsn: '__DSN__',
- *   // ...
- * });
- * ```
- *
- * @example
- * ```
- *
- * import { addBreadcrumb } from '@sentry/browser';
- * addBreadcrumb({
- *   message: 'My Breadcrumb',
- *   // ...
- * });
- * ```
- *
- * @example
- *
- * ```
- *
- * import * as Sentry from '@sentry/browser';
- * Sentry.captureMessage('Hello, world!');
- * Sentry.captureException(new Error('Good bye'));
- * Sentry.captureEvent({
- *   message: 'Manual',
- *   stacktrace: [
- *     // ...
- *   ],
- * });
- * ```
- *
- * @see {@link BrowserOptions} for documentation on configuration options.
- */
-export declare function init(options?: BrowserOptions): Client | undefined;
-/**
- * This function is here to be API compatible with the loader.
- * @hidden
- */
-export declare function forceLoad(): void;
-/**
- * This function is here to be API compatible with the loader.
- * @hidden
- */
-export declare function onLoad(callback: () => void): void;
-//# sourceMappingURL=sdk.d.ts.map

package/build/npm/types-ts3.8/stack-parsers.d.ts

@@ -1,9 +0,0 @@
-import { StackLineParser } from '@sentry/core/browser';
-export declare const chromeStackLineParser: StackLineParser;
-export declare const geckoStackLineParser: StackLineParser;
-export declare const winjsStackLineParser: StackLineParser;
-export declare const opera10StackLineParser: StackLineParser;
-export declare const opera11StackLineParser: StackLineParser;
-export declare const defaultStackLineParsers: StackLineParser[];
-export declare const defaultStackParser: import("@sentry/core").StackParser;
-//# sourceMappingURL=stack-parsers.d.ts.map

package/build/npm/types-ts3.8/tracing/backgroundtab.d.ts

@@ -1,6 +0,0 @@
-/**
- * Add a listener that cancels and finishes a transaction when the global
- * document is hidden.
- */
-export declare function registerBackgroundTabDetection(): void;
-//# sourceMappingURL=backgroundtab.d.ts.map

package/build/npm/types-ts3.8/tracing/browserTracingIntegration.d.ts

@@ -1,271 +0,0 @@
-import { Client, RequestHookInfo, ResponseHookInfo, Span, StartSpanOptions } from '@sentry/core/browser';
-export declare const BROWSER_TRACING_INTEGRATION_ID = "BrowserTracing";
-export declare function isBotUserAgent(): boolean;
-/** Options for Browser Tracing integration */
-export interface BrowserTracingOptions {
-    /**
-     * The time that has to pass without any span being created.
-     * If this time is exceeded, the idle span will finish.
-     *
-     * Default: 1000 (ms)
-     */
-    idleTimeout: number;
-    /**
-     * The max. time an idle span may run.
-     * If this time is exceeded, the idle span will finish no matter what.
-     *
-     * Default: 30000 (ms)
-     */
-    finalTimeout: number;
-    /**
-     The max. time an idle span may run.
-     * If this time is exceeded, the idle span will finish no matter what.
-     *
-     * Default: 15000 (ms)
-     */
-    childSpanTimeout: number;
-    /**
-     * If a span should be created on page load.
-     * If this is set to `false`, this integration will not start the default page load span.
-     * Default: true
-     */
-    instrumentPageLoad: boolean;
-    /**
-     * If a span should be created on navigation (history change).
-     * If this is set to `false`, this integration will not start the default navigation spans.
-     * Default: true
-     */
-    instrumentNavigation: boolean;
-    /**
-     * Flag spans where tabs moved to background with "cancelled". Browser background tab timing is
-     * not suited towards doing precise measurements of operations. By default, we recommend that this option
-     * be enabled as background transactions can mess up your statistics in nondeterministic ways.
-     *
-     * Default: true
-     */
-    markBackgroundSpan: boolean;
-    /**
-     * If true, Sentry will capture long tasks and add them to the corresponding transaction.
-     *
-     * Default: true
-     */
-    enableLongTask: boolean;
-    /**
-     * If true, Sentry will capture long animation frames and add them to the corresponding transaction.
-     *
-     * Default: false
-     */
-    enableLongAnimationFrame: boolean;
-    /**
-     * If true, Sentry will capture first input delay and add it to the corresponding transaction.
-     *
-     * Default: true
-     */
-    enableInp: boolean;
-    /**
-     * @deprecated This option is no longer used. Element timing is now tracked via the standalone
-     * `elementTimingIntegration`. Add it to your `integrations` array to collect element timing metrics.
-     */
-    enableElementTiming?: boolean;
-    /**
-     * Flag to disable patching all together for fetch requests.
-     *
-     * Default: true
-     */
-    traceFetch: boolean;
-    /**
-     * Flag to disable patching all together for xhr requests.
-     *
-     * Default: true
-     */
-    traceXHR: boolean;
-    /**
-     * Flag to disable tracking of long-lived streams, like server-sent events (SSE) via fetch.
-     * Do not enable this in case you have live streams or very long running streams.
-     *
-     * Default: false
-     *
-     * @deprecated Use `fetchStreamPerformanceIntegration()` instead. Add it to your `integrations` array
-     * to track the duration of streamed fetch response bodies.
-     */
-    trackFetchStreamPerformance: boolean;
-    /**
-     * If true, Sentry will capture http timings and add them to the corresponding http spans.
-     *
-     * Default: true
-     */
-    enableHTTPTimings: boolean;
-    /**
-     * Resource spans with `op`s matching strings in the array will not be emitted.
-     *
-     * Default: []
-     */
-    ignoreResourceSpans: Array<'resouce.script' | 'resource.css' | 'resource.img' | 'resource.other' | string>;
-    /**
-     * Spans created from the following browser Performance APIs,
-     *
-     * - [`performance.mark(...)`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/mark)
-     * - [`performance.measure(...)`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/measure)
-     *
-     * will not be emitted if their names match strings in this array.
-     *
-     * This is useful, if you come across `mark` or `measure` spans in your Sentry traces
-     * that you want to ignore. For example, sometimes, browser extensions or libraries
-     * emit these entries on their own, which might not be relevant to your application.
-     *
-     * * @example
-     * ```ts
-     * Sentry.init({
-     *   integrations: [
-     *     Sentry.browserTracingIntegration({
-     *      ignorePerformanceApiSpans: ['myMeasurement', /myMark/],
-     *     }),
-     *   ],
-     * });
-     *
-     * // no spans will be created for these:
-     * performance.mark('myMark');
-     * performance.measure('myMeasurement');
-     *
-     * // spans will be created for these:
-     * performance.mark('authenticated');
-     * performance.measure('input-duration', ...);
-     * ```
-     *
-     * Default: [] - By default, all `mark` and `measure` entries are sent as spans.
-     */
-    ignorePerformanceApiSpans: Array<string | RegExp>;
-    /**
-     * By default, the SDK will try to detect redirects and avoid creating separate spans for them.
-     * If you want to opt-out of this behavior, you can set this option to `false`.
-     *
-     * Default: true
-     */
-    detectRedirects: boolean;
-    /**
-     * Link the currently started trace to a previous trace (e.g. a prior pageload, navigation or
-     * manually started span). When enabled, this option will allow you to navigate between traces
-     * in the Sentry UI.
-     *
-     * You can set this option to the following values:
-     *
-     * - `'in-memory'`: The previous trace data will be stored in memory.
-     *   This is useful for single-page applications and enabled by default.
-     *
-     * - `'session-storage'`: The previous trace data will be stored in the `sessionStorage`.
-     *   This is useful for multi-page applications or static sites but it means that the
-     *   Sentry SDK writes to the browser's `sessionStorage`.
-     *
-     * - `'off'`: The previous trace data will not be stored or linked.
-     *
-     * You can also use {@link BrowserTracingOptions.consistentTraceSampling} to get
-     * consistent trace sampling of subsequent traces. Otherwise, by default, your
-     * `tracesSampleRate` or `tracesSampler` config significantly influences how often
-     * traces will be linked.
-     *
-     * @default 'in-memory' - see explanation above
-     */
-    linkPreviousTrace: 'in-memory' | 'session-storage' | 'off';
-    /**
-     * If true, Sentry will consistently sample subsequent traces based on the
-     * sampling decision of the initial trace. For example, if the initial page
-     * load trace was sampled positively, all subsequent traces (e.g. navigations)
-     * are also sampled positively. In case the initial trace was sampled negatively,
-     * all subsequent traces are also sampled negatively.
-     *
-     * This option allows you to get consistent, linked traces within a user journey
-     * while maintaining an overall quota based on your trace sampling settings.
-     *
-     * This option is only effective if {@link BrowserTracingOptions.linkPreviousTrace}
-     * is enabled (i.e. not set to `'off'`).
-     *
-     * @default `false` - this is an opt-in feature.
-     */
-    consistentTraceSampling: boolean;
-    /**
-     * If set to `true`, the pageload span will not end itself automatically, unless it
-     * runs until the {@link BrowserTracingOptions.finalTimeout} (30 seconds by default) is reached.
-     *
-     * Set this option to `true`, if you want full control over the pageload span duration.
-     * You can use `Sentry.reportPageLoaded()` to manually end the pageload span whenever convenient.
-     * Be aware that you have to ensure that this is always called, regardless of the chosen route
-     * or path in the application.
-     *
-     * @default `false`. By default, the pageload span will end itself automatically, based on
-     * the {@link BrowserTracingOptions.finalTimeout}, {@link BrowserTracingOptions.idleTimeout}
-     * and {@link BrowserTracingOptions.childSpanTimeout}. This is more convenient to use but means
-     * that the pageload duration can be arbitrary and might not be fully representative of a perceived
-     * page load time.
-     */
-    enableReportPageLoaded: boolean;
-    /**
-     * _experiments allows the user to send options to define how this integration works.
-     *
-     * Default: undefined
-     */
-    _experiments: Partial<{
-        enableInteractions: boolean;
-        enableStandaloneClsSpans: boolean;
-        enableStandaloneLcpSpans: boolean;
-    }>;
-    /**
-     * A callback which is called before a span for a pageload or navigation is started.
-     * It receives the options passed to `startSpan`, and expects to return an updated options object.
-     */
-    beforeStartSpan?: (options: StartSpanOptions) => StartSpanOptions;
-    /**
-     * This function will be called before creating a span for a request with the given url.
-     * Return false if you don't want a span for the given url.
-     *
-     * Default: (url: string) => true
-     */
-    shouldCreateSpanForRequest?(this: void, url: string): boolean;
-    /**
-     * This callback is invoked directly after a span is started for an outgoing fetch or XHR request.
-     * You can use it to annotate the span with additional data or attributes, for example by setting
-     * attributes based on the passed request headers.
-     */
-    onRequestSpanStart?(span: Span, requestInformation: RequestHookInfo): void;
-    /**
-     * Is called when spans end for outgoing requests, providing access to response headers.
-     */
-    onRequestSpanEnd?(span: Span, responseInformation: ResponseHookInfo): void;
-}
-/**
- * The Browser Tracing integration automatically instruments browser pageload/navigation
- * actions as transactions, and captures requests, metrics and errors as spans.
- *
- * The integration can be configured with a variety of options, and can be extended to use
- * any routing library.
- *
- * We explicitly export the proper type here, as this has to be extended in some cases.
- */
-export declare const browserTracingIntegration: (options?: Partial<BrowserTracingOptions>) => {
-    name: string;
-    setup(client: Client<import("@sentry/core").ClientOptions<import("@sentry/core").BaseTransportOptions>>): void;
-    afterAllSetup(client: Client<import("@sentry/core").ClientOptions<import("@sentry/core").BaseTransportOptions>>): void;
-};
-/**
- * Manually start a page load span.
- * This will only do something if a browser tracing integration integration has been setup.
- *
- * If you provide a custom `traceOptions` object, it will be used to continue the trace
- * instead of the default behavior, which is to look it up on the <meta> tags.
- */
-export declare function startBrowserTracingPageLoadSpan(client: Client, spanOptions: StartSpanOptions, traceOptions?: {
-    sentryTrace?: string | undefined;
-    baggage?: string | undefined;
-}): Span | undefined;
-/**
- * Manually start a navigation span.
- * This will only do something if a browser tracing integration has been setup.
- */
-export declare function startBrowserTracingNavigationSpan(client: Client, spanOptions: StartSpanOptions, options?: {
-    url?: string;
-    isRedirect?: boolean;
-}): Span | undefined;
-/** Returns the value of a meta tag */
-export declare function getMetaContent(metaName: string): string | undefined;
-/** Returns the description of a server timing entry */
-export declare function getServerTiming(name: string): string | undefined;
-//# sourceMappingURL=browserTracingIntegration.d.ts.map

package/build/npm/types-ts3.8/tracing/linkedTraces.d.ts

@@ -1,52 +0,0 @@
-import { Client, PropagationContext, Span, SpanContextData } from '@sentry/core/browser';
-export interface PreviousTraceInfo {
-    /**
-     * Span context of the previous trace's local root span
-     */
-    spanContext: SpanContextData;
-    /**
-     * Timestamp in seconds when the previous trace was started
-     */
-    startTimestamp: number;
-    /**
-     * sample rate of the previous trace
-     */
-    sampleRate: number;
-    /**
-     * The sample rand of the previous trace
-     */
-    sampleRand: number;
-}
-export declare const PREVIOUS_TRACE_MAX_DURATION = 3600;
-export declare const PREVIOUS_TRACE_KEY = "sentry_previous_trace";
-export declare const PREVIOUS_TRACE_TMP_SPAN_ATTRIBUTE = "sentry.previous_trace";
-/**
- * Takes care of linking traces and applying the (consistent) sampling behavoiour based on the passed options
- * @param options - options for linking traces and consistent trace sampling (@see BrowserTracingOptions)
- * @param client - Sentry client
- */
-export declare function linkTraces(client: Client, { linkPreviousTrace, consistentTraceSampling, }: {
-    linkPreviousTrace: 'session-storage' | 'in-memory';
-    consistentTraceSampling: boolean;
-}): void;
-/**
- * Adds a previous_trace span link to the passed span if the passed
- * previousTraceInfo is still valid.
- *
- * @returns the updated previous trace info (based on the current span/trace) to
- * be used on the next call
- */
-export declare function addPreviousTraceSpanLink(previousTraceInfo: PreviousTraceInfo | undefined, span: Span, oldPropagationContext: PropagationContext): PreviousTraceInfo;
-/**
- * Stores @param previousTraceInfo in sessionStorage.
- */
-export declare function storePreviousTraceInSessionStorage(previousTraceInfo: PreviousTraceInfo): void;
-/**
- * Retrieves the previous trace from sessionStorage if available.
- */
-export declare function getPreviousTraceFromSessionStorage(): PreviousTraceInfo | undefined;
-/**
- * see {@link import('@sentry/core/browser').spanIsSampled}
- */
-export declare function spanContextSampled(ctx: SpanContextData): boolean;
-//# sourceMappingURL=linkedTraces.d.ts.map

package/build/npm/types-ts3.8/tracing/reportPageLoaded.d.ts

@@ -1,11 +0,0 @@
-import { Client } from '@sentry/core/browser';
-/**
- * Manually report the end of the page load, resulting in the SDK ending the pageload span.
- * This only works if {@link BrowserTracingOptions.enableReportPageLoaded} is set to `true`.
- * Otherwise, the pageload span will end itself based on the {@link BrowserTracingOptions.finalTimeout},
- * {@link BrowserTracingOptions.idleTimeout} and {@link BrowserTracingOptions.childSpanTimeout}.
- *
- * @param client - The client to use. If not provided, the global client will be used.
- */
-export declare function reportPageLoaded(client?: Client | undefined): void;
-//# sourceMappingURL=reportPageLoaded.d.ts.map

package/build/npm/types-ts3.8/tracing/request.d.ts

@@ -1,87 +0,0 @@
-import { Client, RequestHookInfo, ResponseHookInfo, Span } from '@sentry/core/browser';
-/** Options for Request Instrumentation */
-export interface RequestInstrumentationOptions {
-    /**
-     * List of strings and/or Regular Expressions used to determine which outgoing requests will have `sentry-trace` and `baggage`
-     * headers attached.
-     *
-     * **Default:** If this option is not provided, tracing headers will be attached to all outgoing requests.
-     * If you are using a browser SDK, by default, tracing headers will only be attached to outgoing requests to the same origin.
-     *
-     * **Disclaimer:** Carelessly setting this option in browser environments may result into CORS errors!
-     * Only attach tracing headers to requests to the same origin, or to requests to services you can control CORS headers of.
-     * Cross-origin requests, meaning requests to a different domain, for example a request to `https://api.example.com/` while you're on `https://example.com/`, take special care.
-     * If you are attaching headers to cross-origin requests, make sure the backend handling the request returns a `"Access-Control-Allow-Headers: sentry-trace, baggage"` header to ensure your requests aren't blocked.
-     *
-     * If you provide a `tracePropagationTargets` array, the entries you provide will be matched against the entire URL of the outgoing request.
-     * If you are using a browser SDK, the entries will also be matched against the pathname of the outgoing requests.
-     * This is so you can have matchers for relative requests, for example, `/^\/api/` if you want to trace requests to your `/api` routes on the same domain.
-     *
-     * If any of the two match any of the provided values, tracing headers will be attached to the outgoing request.
-     * Both, the string values, and the RegExes you provide in the array will match if they partially match the URL or pathname.
-     *
-     * Examples:
-     * - `tracePropagationTargets: [/^\/api/]` and request to `https://same-origin.com/api/posts`:
-     *   - Tracing headers will be attached because the request is sent to the same origin and the regex matches the pathname "/api/posts".
-     * - `tracePropagationTargets: [/^\/api/]` and request to `https://different-origin.com/api/posts`:
-     *   - Tracing headers will not be attached because the pathname will only be compared when the request target lives on the same origin.
-     * - `tracePropagationTargets: [/^\/api/, 'https://external-api.com']` and request to `https://external-api.com/v1/data`:
-     *   - Tracing headers will be attached because the request URL matches the string `'https://external-api.com'`.
-     */
-    tracePropagationTargets?: Array<string | RegExp>;
-    /**
-     * Flag to disable patching all together for fetch requests.
-     *
-     * Default: true
-     */
-    traceFetch: boolean;
-    /**
-     * Flag to disable patching all together for xhr requests.
-     *
-     * Default: true
-     */
-    traceXHR: boolean;
-    /**
-     * Flag to disable tracking of long-lived streams, like server-sent events (SSE) via fetch.
-     * Do not enable this in case you have live streams or very long running streams.
-     *
-     * Disabled by default since it can lead to issues with streams using the `cancel()` api
-     * (https://github.com/getsentry/sentry-javascript/issues/13950)
-     *
-     * Default: false
-     *
-     * @deprecated Use `fetchStreamPerformanceIntegration()` instead. Add it to your `integrations` array
-     * to track the duration of streamed fetch response bodies.
-     */
-    trackFetchStreamPerformance: boolean;
-    /**
-     * If true, Sentry will capture http timings and add them to the corresponding http spans.
-     *
-     * Default: true
-     */
-    enableHTTPTimings: boolean;
-    /**
-     * This function will be called before creating a span for a request with the given url.
-     * Return false if you don't want a span for the given url.
-     *
-     * Default: (url: string) => true
-     */
-    shouldCreateSpanForRequest?(this: void, url: string): boolean;
-    /**
-     * Is called when spans are started for outgoing requests.
-     */
-    onRequestSpanStart?(span: Span, requestInformation: RequestHookInfo): void;
-    /**
-     * Is called when spans end for outgoing requests, providing access to response headers.
-     */
-    onRequestSpanEnd?(span: Span, responseInformation: ResponseHookInfo): void;
-}
-export declare const defaultRequestInstrumentationOptions: RequestInstrumentationOptions;
-/** Registers span creators for xhr and fetch requests  */
-export declare function instrumentOutgoingRequests(client: Client, _options?: Partial<RequestInstrumentationOptions>): void;
-/**
- * A function that determines whether to attach tracing headers to a request.
- * We only export this function for testing purposes.
- */
-export declare function shouldAttachHeaders(targetUrl: string, tracePropagationTargets: (string | RegExp)[] | undefined): boolean;
-//# sourceMappingURL=request.d.ts.map

package/build/npm/types-ts3.8/tracing/setActiveSpan.d.ts

@@ -1,39 +0,0 @@
-import { Span } from '@sentry/core/browser';
-/**
- * Sets an inactive span active on the current scope.
- *
- * This is useful in browser applications, if you want to create a span that cannot be finished
- * within its callback. Any spans started while the given span is active, will be children of the span.
- *
- * If there already was an active span on the scope prior to calling this function, it is replaced
- * with the given span and restored after the span ended. Otherwise, the span will simply be
- * removed, resulting in no active span on the scope.
- *
- * IMPORTANT: This function can ONLY be used in the browser! Calling this function in a server
- * environment (for example in a server-side rendered component) will result in undefined behaviour
- * and is not supported.
- * You MUST call `span.end()` manually, otherwise the span will never be finished.
- *
- * @example
- * ```js
- * let checkoutSpan;
- *
- * on('checkoutStarted', () => {
- *  checkoutSpan = Sentry.startInactiveSpan({ name: 'checkout-flow' });
- *  Sentry.setActiveSpanInBrowser(checkoutSpan);
- * })
- *
- * // during this time, any spans started will be children of `checkoutSpan`:
- * Sentry.startSpan({ name: 'checkout-step-1' }, () => {
- *  // ... `
- * })
- *
- * on('checkoutCompleted', () => {
- *  checkoutSpan?.end();
- * })
- * ```
- *
- * @param span - the span to set active
- */
-export declare function setActiveSpanInBrowser(span: Span): void;
-//# sourceMappingURL=setActiveSpan.d.ts.map