@sentry/browser 10.69.0 → 11.0.0-alpha.0

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

@@ -1,75 +0,0 @@
-import { Client, ContinuousProfiler, Span } from '@sentry/core/browser';
-/**
- * UIProfiler (Profiling V2):
- * Supports two lifecycle modes:
- *  - 'manual': controlled explicitly via start()/stop()
- *  - 'trace': automatically runs while there are active sampled root spans
- *
- * Profiles are emitted as standalone `profile_chunk` envelopes either when:
- * - there are no more sampled root spans, or
- * - the 60s chunk timer elapses while profiling is running.
- */
-export declare class UIProfiler implements ContinuousProfiler<Client> {
-    private _client;
-    private _profiler;
-    private _chunkTimer;
-    private _profilerId;
-    private _isRunning;
-    private _sessionSampled;
-    private _lifecycleMode;
-    private _activeRootSpanIds;
-    private _rootSpanTimeouts;
-    constructor();
-    /**
-     * Initialize the profiler with client, session sampling and lifecycle mode.
-     */
-    initialize(client: Client): void;
-    /** Starts UI profiling (only effective in 'manual' mode and when sampled). */
-    start(): void;
-    /** Stops UI profiling (only effective in 'manual' mode). */
-    stop(): void;
-    /** Handle an already-active root span at integration setup time (used only in trace mode). */
-    notifyRootSpanActive(rootSpan: Span): void;
-    /**
-     * Begin profiling if not already running.
-     */
-    private _beginProfiling;
-    /** End profiling session; final chunk will be collected and sent. */
-    private _endProfiling;
-    /** Trace-mode: attach spanStart/spanEnd listeners. */
-    private _setupTraceLifecycleListeners;
-    /**
-     * Resets profiling information from scope and resets running state (used on failure)
-     */
-    private _resetProfilerInfo;
-    /**
-     * Clear and reset all per-root-span timeouts.
-     */
-    private _clearAllRootSpanTimeouts;
-    /** Keep track of root spans and schedule safeguard timeout (trace mode). */
-    private _registerTraceRootSpan;
-    /**
-     * Start a profiler instance if needed.
-     */
-    private _startProfilerInstance;
-    /**
-     * Schedule the next 60s chunk while running.
-     * Each tick collects a chunk and restarts the profiler.
-     * A chunk should be closed when there are no active root spans anymore OR when the maximum chunk interval is reached.
-     */
-    private _startPeriodicChunking;
-    /**
-     * Handle timeout for a specific root span ID to avoid indefinitely running profiler if `spanEnd` never fires.
-     * If this was the last active root span, collect the current chunk and stop profiling.
-     */
-    private _onRootSpanTimeout;
-    /**
-     * Stop current profiler instance, convert profile to chunk & send.
-     */
-    private _collectCurrentChunk;
-    /**
-     * Send a profile chunk as a standalone envelope.
-     */
-    private _sendProfileChunk;
-}
-//# sourceMappingURL=UIProfiler.d.ts.map

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

@@ -1,8 +0,0 @@
-import { Profiler } from '@sentry/core/browser';
-/**
- * Profiler namespace for controlling the JS profiler in 'manual' mode.
- *
- * Requires the `browserProfilingIntegration` from the `@sentry/browser` package.
- */
-export declare const uiProfiler: Profiler;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,4 +0,0 @@
-export declare const browserProfilingIntegration: () => import("@sentry/core").Integration & {
-    name: "BrowserProfiling";
-};
-//# sourceMappingURL=integration.d.ts.map

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

@@ -1,41 +0,0 @@
-type JSSelfProfileSampleMarker = 'script' | 'gc' | 'style' | 'layout' | 'paint' | 'other';
-export type JSSelfProfileSample = {
-    timestamp: number;
-    stackId?: number;
-    marker?: JSSelfProfileSampleMarker;
-};
-export type JSSelfProfileStack = {
-    frameId: number;
-    parentId?: number;
-};
-export type JSSelfProfileFrame = {
-    name: string;
-    resourceId?: number;
-    line?: number;
-    column?: number;
-};
-export type JSSelfProfile = {
-    resources: string[];
-    frames: JSSelfProfileFrame[];
-    stacks: JSSelfProfileStack[];
-    samples: JSSelfProfileSample[];
-};
-export interface JSSelfProfiler {
-    sampleInterval: number;
-    stopped: boolean;
-    stop: () => Promise<JSSelfProfile>;
-    addEventListener(event: 'samplebufferfull', callback: (trace: JSSelfProfile) => void): void;
-}
-export declare const JSSelfProfilerConstructor: {
-    new (options: {
-        sampleInterval: number;
-        maxBufferSize: number;
-    }): JSSelfProfiler;
-};
-declare global {
-    interface Window {
-        Profiler: typeof JSSelfProfilerConstructor | undefined;
-    }
-}
-export {};
-//# sourceMappingURL=jsSelfProfiling.d.ts.map

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

@@ -1,8 +0,0 @@
-import { Span } from '@sentry/core/browser';
-/**
- * Wraps startTransaction and stopTransaction with profiling related logic.
- * startProfileForTransaction is called after the call to startTransaction in order to avoid our own code from
- * being profiled. Because of that same reason, stopProfiling is called before the call to stopTransaction.
- */
-export declare function startProfileForSpan(span: Span): void;
-//# sourceMappingURL=startProfileForSpan.d.ts.map

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