@m5kdev/web-ui 0.8.6 → 0.8.8

package/dist/node_modules/.pnpm/@sentry_core@10.22.0/node_modules/@sentry/core/build/types/scope.d.ts

@@ -0,0 +1,289 @@
+import { Attachment } from "./types-hoist/attachment.js";
+import { SeverityLevel } from "./types-hoist/severity.js";
+import { Breadcrumb } from "./types-hoist/breadcrumb.js";
+import { Span } from "./types-hoist/span.js";
+import { RequestEventData } from "./types-hoist/request.js";
+import { Primitive } from "./types-hoist/misc.js";
+import { Context, Contexts } from "./types-hoist/context.js";
+import { User } from "./types-hoist/user.js";
+import { Session } from "./types-hoist/session.js";
+import { DynamicSamplingContext } from "./types-hoist/envelope.js";
+import { EventProcessor } from "./types-hoist/eventprocessor.js";
+import { Extra, Extras } from "./types-hoist/extra.js";
+import { PropagationContext } from "./types-hoist/tracing.js";
+import { Event, EventHint } from "./types-hoist/event.js";
+import { Client } from "./client.js";
+
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/scope.d.ts
+/**
+ * A context to be used for capturing an event.
+ * This can either be a Scope, or a partial ScopeContext,
+ * or a callback that receives the current scope and returns a new scope to use.
+ */
+type CaptureContext = Scope | Partial<ScopeContext> | ((scope: Scope) => Scope);
+/**
+ * Data that can be converted to a Scope.
+ */
+interface ScopeContext {
+  user: User;
+  level: SeverityLevel;
+  extra: Extras;
+  contexts: Contexts;
+  tags: {
+    [key: string]: Primitive;
+  };
+  fingerprint: string[];
+  propagationContext: PropagationContext;
+}
+interface SdkProcessingMetadata {
+  [key: string]: unknown;
+  requestSession?: {
+    status: 'ok' | 'errored' | 'crashed';
+  };
+  normalizedRequest?: RequestEventData;
+  dynamicSamplingContext?: Partial<DynamicSamplingContext>;
+  capturedSpanScope?: Scope;
+  capturedSpanIsolationScope?: Scope;
+  spanCountBeforeProcessing?: number;
+  ipAddress?: string;
+}
+/**
+ * Normalized data of the Scope, ready to be used.
+ */
+interface ScopeData {
+  eventProcessors: EventProcessor[];
+  breadcrumbs: Breadcrumb[];
+  user: User;
+  tags: {
+    [key: string]: Primitive;
+  };
+  extra: Extras;
+  contexts: Contexts;
+  attachments: Attachment[];
+  propagationContext: PropagationContext;
+  sdkProcessingMetadata: SdkProcessingMetadata;
+  fingerprint: string[];
+  level?: SeverityLevel;
+  transactionName?: string;
+  span?: Span;
+}
+/**
+ * Holds additional event information.
+ */
+declare class Scope {
+  /** Flag if notifying is happening. */
+  protected _notifyingListeners: boolean;
+  /** Callback for client to receive scope changes. */
+  protected _scopeListeners: Array<(scope: Scope) => void>;
+  /** Callback list that will be called during event processing. */
+  protected _eventProcessors: EventProcessor[];
+  /** Array of breadcrumbs. */
+  protected _breadcrumbs: Breadcrumb[];
+  /** User */
+  protected _user: User;
+  /** Tags */
+  protected _tags: {
+    [key: string]: Primitive;
+  };
+  /** Extra */
+  protected _extra: Extras;
+  /** Contexts */
+  protected _contexts: Contexts;
+  /** Attachments */
+  protected _attachments: Attachment[];
+  /** Propagation Context for distributed tracing */
+  protected _propagationContext: PropagationContext;
+  /**
+   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get
+   * sent to Sentry
+   */
+  protected _sdkProcessingMetadata: SdkProcessingMetadata;
+  /** Fingerprint */
+  protected _fingerprint?: string[];
+  /** Severity */
+  protected _level?: SeverityLevel;
+  /**
+   * Transaction Name
+   *
+   * IMPORTANT: The transaction name on the scope has nothing to do with root spans/transaction objects.
+   * It's purpose is to assign a transaction to the scope that's added to non-transaction events.
+   */
+  protected _transactionName?: string;
+  /** Session */
+  protected _session?: Session;
+  /** The client on this scope */
+  protected _client?: Client;
+  /** Contains the last event id of a captured event.  */
+  protected _lastEventId?: string;
+  constructor();
+  /**
+   * Clone all data from this scope into a new scope.
+   */
+  clone(): Scope;
+  /**
+   * Update the client assigned to this scope.
+   * Note that not every scope will have a client assigned - isolation scopes & the global scope will generally not have a client,
+   * as well as manually created scopes.
+   */
+  setClient(client: Client | undefined): void;
+  /**
+   * Set the ID of the last captured error event.
+   * This is generally only captured on the isolation scope.
+   */
+  setLastEventId(lastEventId: string | undefined): void;
+  /**
+   * Get the client assigned to this scope.
+   */
+  getClient<C extends Client>(): C | undefined;
+  /**
+   * Get the ID of the last captured error event.
+   * This is generally only available on the isolation scope.
+   */
+  lastEventId(): string | undefined;
+  /**
+   * @inheritDoc
+   */
+  addScopeListener(callback: (scope: Scope) => void): void;
+  /**
+   * Add an event processor that will be called before an event is sent.
+   */
+  addEventProcessor(callback: EventProcessor): this;
+  /**
+   * Set the user for this scope.
+   * Set to `null` to unset the user.
+   */
+  setUser(user: User | null): this;
+  /**
+   * Get the user from this scope.
+   */
+  getUser(): User | undefined;
+  /**
+   * Set an object that will be merged into existing tags on the scope,
+   * and will be sent as tags data with the event.
+   */
+  setTags(tags: {
+    [key: string]: Primitive;
+  }): this;
+  /**
+   * Set a single tag that will be sent as tags data with the event.
+   */
+  setTag(key: string, value: Primitive): this;
+  /**
+   * Set an object that will be merged into existing extra on the scope,
+   * and will be sent as extra data with the event.
+   */
+  setExtras(extras: Extras): this;
+  /**
+   * Set a single key:value extra entry that will be sent as extra data with the event.
+   */
+  setExtra(key: string, extra: Extra): this;
+  /**
+   * Sets the fingerprint on the scope to send with the events.
+   * @param {string[]} fingerprint Fingerprint to group events in Sentry.
+   */
+  setFingerprint(fingerprint: string[]): this;
+  /**
+   * Sets the level on the scope for future events.
+   */
+  setLevel(level: SeverityLevel): this;
+  /**
+   * Sets the transaction name on the scope so that the name of e.g. taken server route or
+   * the page location is attached to future events.
+   *
+   * IMPORTANT: Calling this function does NOT change the name of the currently active
+   * root span. If you want to change the name of the active root span, use
+   * `Sentry.updateSpanName(rootSpan, 'new name')` instead.
+   *
+   * By default, the SDK updates the scope's transaction name automatically on sensible
+   * occasions, such as a page navigation or when handling a new request on the server.
+   */
+  setTransactionName(name?: string): this;
+  /**
+   * Sets context data with the given name.
+   * Data passed as context will be normalized. You can also pass `null` to unset the context.
+   * Note that context data will not be merged - calling `setContext` will overwrite an existing context with the same key.
+   */
+  setContext(key: string, context: Context | null): this;
+  /**
+   * Set the session for the scope.
+   */
+  setSession(session?: Session): this;
+  /**
+   * Get the session from the scope.
+   */
+  getSession(): Session | undefined;
+  /**
+   * Updates the scope with provided data. Can work in three variations:
+   * - plain object containing updatable attributes
+   * - Scope instance that'll extract the attributes from
+   * - callback function that'll receive the current scope as an argument and allow for modifications
+   */
+  update(captureContext?: CaptureContext): this;
+  /**
+   * Clears the current scope and resets its properties.
+   * Note: The client will not be cleared.
+   */
+  clear(): this;
+  /**
+   * Adds a breadcrumb to the scope.
+   * By default, the last 100 breadcrumbs are kept.
+   */
+  addBreadcrumb(breadcrumb: Breadcrumb, maxBreadcrumbs?: number): this;
+  /**
+   * Get the last breadcrumb of the scope.
+   */
+  getLastBreadcrumb(): Breadcrumb | undefined;
+  /**
+   * Clear all breadcrumbs from the scope.
+   */
+  clearBreadcrumbs(): this;
+  /**
+   * Add an attachment to the scope.
+   */
+  addAttachment(attachment: Attachment): this;
+  /**
+   * Clear all attachments from the scope.
+   */
+  clearAttachments(): this;
+  /**
+   * Get the data of this scope, which should be applied to an event during processing.
+   */
+  getScopeData(): ScopeData;
+  /**
+   * Add data which will be accessible during event processing but won't get sent to Sentry.
+   */
+  setSDKProcessingMetadata(newData: SdkProcessingMetadata): this;
+  /**
+   * Add propagation context to the scope, used for distributed tracing
+   */
+  setPropagationContext(context: PropagationContext): this;
+  /**
+   * Get propagation context from the scope, used for distributed tracing
+   */
+  getPropagationContext(): PropagationContext;
+  /**
+   * Capture an exception for this scope.
+   *
+   * @returns {string} The id of the captured Sentry event.
+   */
+  captureException(exception: unknown, hint?: EventHint): string;
+  /**
+   * Capture a message for this scope.
+   *
+   * @returns {string} The id of the captured message.
+   */
+  captureMessage(message: string, level?: SeverityLevel, hint?: EventHint): string;
+  /**
+   * Capture a Sentry event for this scope.
+   *
+   * @returns {string} The id of the captured event.
+   */
+  captureEvent(event: Event, hint?: EventHint): string;
+  /**
+   * This will be called on every set call.
+   */
+  protected _notifyScopeListeners(): void;
+}
+//#endregion
+export { CaptureContext, Scope, ScopeContext, SdkProcessingMetadata };
+//# sourceMappingURL=scope.d.ts.map

package/dist/node_modules/.pnpm/@sentry_core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/attachment.d.ts

@@ -0,0 +1,32 @@
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/attachment.d.ts
+type AttachmentType = 'event.attachment' | 'event.minidump' | 'event.applecrashreport' | 'unreal.context' | 'unreal.logs' | 'event.view_hierarchy';
+/**
+ * An attachment to an event. This is used to upload arbitrary data to Sentry.
+ *
+ * Please take care to not add sensitive information in attachments.
+ *
+ * https://develop.sentry.dev/sdk/envelopes/#attachment
+ */
+interface Attachment {
+  /**
+   * The attachment data. Can be a string or a binary data (byte array)
+   */
+  data: string | Uint8Array;
+  /**
+   * The name of the uploaded file without a path component
+   */
+  filename: string;
+  /**
+   * The content type of the attachment payload. Defaults to `application/octet-stream` if not specified.
+   *
+   * Any valid [media type](https://www.iana.org/assignments/media-types/media-types.xhtml) is allowed.
+   */
+  contentType?: string;
+  /**
+   * The type of the attachment. Defaults to `event.attachment` if not specified.
+   */
+  attachmentType?: AttachmentType;
+}
+//#endregion
+export { Attachment, AttachmentType };
+//# sourceMappingURL=attachment.d.ts.map

package/dist/node_modules/.pnpm/@sentry_core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/breadcrumb.d.ts

@@ -0,0 +1,86 @@
+import { SeverityLevel } from "./severity.js";
+
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/breadcrumb.d.ts
+/**
+ * Sentry uses breadcrumbs to create a trail of events that happened prior to an issue.
+ * These events are very similar to traditional logs but can record more rich structured data.
+ *
+ * @link https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/
+ */
+interface Breadcrumb {
+  /**
+   * By default, all breadcrumbs are recorded as default, which makes them appear as a Debug entry, but Sentry provides
+   * other types that influence how the breadcrumbs are rendered. For more information, see the description of
+   * recognized breadcrumb types.
+   *
+   * @summary The type of breadcrumb.
+   * @link https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/#breadcrumb-types
+   */
+  type?: string;
+  /**
+   * Allowed values are, from highest to lowest:
+   * `fatal`, `error`, `warning`, `info`, and `debug`.
+   * Levels are used in the UI to emphasize and deemphasize the crumb. The default is `info`.
+   *
+   * @summary This defines the severity level of the breadcrumb.
+   */
+  level?: SeverityLevel;
+  event_id?: string;
+  /**
+   * Typically it is a module name or a descriptive string. For instance, `ui.click` could be used to
+   * indicate that a click happened in the UI or flask could be used to indicate that the event originated in
+   * the Flask framework.
+   * @private Internally we render some crumbs' color and icon based on the provided category.
+   *          For more information, see the description of recognized breadcrumb types.
+   * @summary A dotted string indicating what the crumb is or from where it comes.
+   * @link    https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/#breadcrumb-types
+   */
+  category?: string;
+  /**
+   * If a message is provided, it is rendered as text with all whitespace preserved.
+   *
+   * @summary Human-readable message for the breadcrumb.
+   */
+  message?: string;
+  /**
+   * Contains a dictionary whose contents depend on the breadcrumb type.
+   * Additional parameters that are unsupported by the type are rendered as a key/value table.
+   *
+   * @summary Arbitrary data associated with this breadcrumb.
+   */
+  data?: {
+    [key: string]: any;
+  };
+  /**
+   * The format is a numeric (integer or float) value representing
+   * the number of seconds that have elapsed since the Unixepoch.
+   * Breadcrumbs are most useful when they include a timestamp, as it creates a timeline
+   * leading up to an event expection/error.
+   *
+   * @note The API supports a string as defined in RFC 3339, but the SDKs only support a numeric value for now.
+   *
+   * @summary A timestamp representing when the breadcrumb occurred.
+   * @link https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/#:~:text=is%20info.-,timestamp,-(recommended)
+   */
+  timestamp?: number;
+}
+/** JSDoc */
+interface BreadcrumbHint {
+  [key: string]: any;
+}
+interface FetchBreadcrumbHint {
+  input: any[];
+  data?: unknown;
+  response?: unknown;
+  startTimestamp: number;
+  endTimestamp?: number;
+}
+interface XhrBreadcrumbHint {
+  xhr: unknown;
+  input: unknown;
+  startTimestamp: number;
+  endTimestamp: number;
+}
+//#endregion
+export { Breadcrumb, BreadcrumbHint, FetchBreadcrumbHint, XhrBreadcrumbHint };
+//# sourceMappingURL=breadcrumb.d.ts.map

package/dist/node_modules/.pnpm/@sentry_core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/checkin.d.ts

@@ -0,0 +1,101 @@
+import { TraceContext } from "./context.js";
+
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/checkin.d.ts
+interface CrontabSchedule {
+  type: 'crontab';
+  /** The crontab schedule string, e.g. 0 * * * *. */
+  value: string;
+}
+interface IntervalSchedule {
+  type: 'interval';
+  value: number;
+  unit: 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute';
+}
+type MonitorSchedule = CrontabSchedule | IntervalSchedule;
+interface SerializedCheckIn {
+  /** Check-In ID (unique and client generated). */
+  check_in_id: string;
+  /** The distinct slug of the monitor. */
+  monitor_slug: string;
+  /** The status of the check-in. */
+  status: 'in_progress' | 'ok' | 'error';
+  /** The duration of the check-in in seconds. Will only take effect if the status is ok or error. */
+  duration?: number;
+  release?: string;
+  environment?: string;
+  monitor_config?: {
+    schedule: MonitorSchedule;
+    /**
+     * The allowed allowed margin of minutes after the expected check-in time that
+     * the monitor will not be considered missed for.
+     */
+    checkin_margin?: number;
+    /**
+     * The allowed allowed duration in minutes that the monitor may be `in_progress`
+     * for before being considered failed due to timeout.
+     */
+    max_runtime?: number;
+    /**
+     * A tz database string representing the timezone which the monitor's execution schedule is in.
+     * See: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+     */
+    timezone?: string; /** How many consecutive failed check-ins it takes to create an issue. */
+    failure_issue_threshold?: number; /** How many consecutive OK check-ins it takes to resolve an issue. */
+    recovery_threshold?: number;
+  };
+  contexts?: {
+    trace?: TraceContext;
+  };
+}
+interface HeartbeatCheckIn {
+  /** The distinct slug of the monitor. */
+  monitorSlug: SerializedCheckIn['monitor_slug'];
+  /** The status of the check-in. */
+  status: 'ok' | 'error';
+}
+interface InProgressCheckIn {
+  /** The distinct slug of the monitor. */
+  monitorSlug: SerializedCheckIn['monitor_slug'];
+  /** The status of the check-in. */
+  status: 'in_progress';
+}
+interface FinishedCheckIn {
+  /** The distinct slug of the monitor. */
+  monitorSlug: SerializedCheckIn['monitor_slug'];
+  /** The status of the check-in. */
+  status: 'ok' | 'error';
+  /** Check-In ID (unique and client generated). */
+  checkInId: SerializedCheckIn['check_in_id'];
+  /** The duration of the check-in in seconds. Will only take effect if the status is ok or error. */
+  duration?: SerializedCheckIn['duration'];
+}
+type CheckIn = HeartbeatCheckIn | InProgressCheckIn | FinishedCheckIn;
+type SerializedMonitorConfig = NonNullable<SerializedCheckIn['monitor_config']>;
+interface MonitorConfig {
+  /**
+   * The schedule on which the monitor should run. Either a crontab schedule string or an interval.
+   */
+  schedule: MonitorSchedule;
+  /**
+   * The allowed allowed margin of minutes after the expected check-in time that
+   * the monitor will not be considered missed for.
+   */
+  checkinMargin?: SerializedMonitorConfig['checkin_margin'];
+  /**
+   * The allowed allowed duration in minutes that the monitor may be `in_progress`
+   * for before being considered failed due to timeout.
+   */
+  maxRuntime?: SerializedMonitorConfig['max_runtime'];
+  /**
+   * A tz database string representing the timezone which the monitor's execution schedule is in.
+   * See: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
+   */
+  timezone?: SerializedMonitorConfig['timezone'];
+  /** How many consecutive failed check-ins it takes to create an issue. */
+  failureIssueThreshold?: SerializedMonitorConfig['failure_issue_threshold'];
+  /** How many consecutive OK check-ins it takes to resolve an issue. */
+  recoveryThreshold?: SerializedMonitorConfig['recovery_threshold'];
+}
+//#endregion
+export { CheckIn, MonitorConfig, SerializedCheckIn };
+//# sourceMappingURL=checkin.d.ts.map

package/dist/node_modules/.pnpm/@sentry_core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/clientreport.d.ts

@@ -0,0 +1,16 @@
+import { DataCategory } from "./datacategory.js";
+
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/clientreport.d.ts
+type EventDropReason = 'before_send' | 'event_processor' | 'network_error' | 'queue_overflow' | 'ratelimit_backoff' | 'sample_rate' | 'send_error' | 'internal_sdk_error' | 'buffer_overflow';
+type Outcome = {
+  reason: EventDropReason;
+  category: DataCategory;
+  quantity: number;
+};
+type ClientReport = {
+  timestamp: number;
+  discarded_events: Outcome[];
+};
+//#endregion
+export { ClientReport, EventDropReason, Outcome };
+//# sourceMappingURL=clientreport.d.ts.map

package/dist/node_modules/.pnpm/@sentry_core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/context.d.ts

@@ -0,0 +1,132 @@
+import { FeatureFlag } from "../utils/featureFlags.js";
+import { SpanOrigin } from "./span.js";
+import { SpanLinkJSON } from "./link.js";
+import { Primitive } from "./misc.js";
+
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/context.d.ts
+type Context = Record<string, unknown>;
+interface Contexts extends Record<string, Context | undefined> {
+  app?: AppContext;
+  device?: DeviceContext;
+  os?: OsContext;
+  culture?: CultureContext;
+  response?: ResponseContext;
+  trace?: TraceContext;
+  cloud_resource?: CloudResourceContext;
+  state?: StateContext;
+  profile?: ProfileContext;
+  flags?: FeatureFlagContext;
+}
+interface StateContext extends Record<string, unknown> {
+  state: {
+    type: string;
+    value: Record<string, unknown>;
+  };
+}
+interface AppContext extends Record<string, unknown> {
+  app_name?: string;
+  app_start_time?: string;
+  app_version?: string;
+  app_identifier?: string;
+  build_type?: string;
+  app_memory?: number;
+  free_memory?: number;
+}
+interface DeviceContext extends Record<string, unknown> {
+  name?: string;
+  family?: string;
+  model?: string;
+  model_id?: string;
+  arch?: string;
+  battery_level?: number;
+  orientation?: 'portrait' | 'landscape';
+  manufacturer?: string;
+  brand?: string;
+  screen_resolution?: string;
+  screen_height_pixels?: number;
+  screen_width_pixels?: number;
+  screen_density?: number;
+  screen_dpi?: number;
+  online?: boolean;
+  charging?: boolean;
+  low_memory?: boolean;
+  simulator?: boolean;
+  memory_size?: number;
+  free_memory?: number;
+  usable_memory?: number;
+  storage_size?: number;
+  free_storage?: number;
+  external_storage_size?: number;
+  external_free_storage?: number;
+  boot_time?: string;
+  processor_count?: number;
+  cpu_description?: string;
+  processor_frequency?: number;
+  device_type?: string;
+  battery_status?: string;
+  device_unique_identifier?: string;
+  supports_vibration?: boolean;
+  supports_accelerometer?: boolean;
+  supports_gyroscope?: boolean;
+  supports_audio?: boolean;
+  supports_location_service?: boolean;
+}
+interface OsContext extends Record<string, unknown> {
+  name?: string;
+  version?: string;
+  build?: string;
+  kernel_version?: string;
+}
+interface CultureContext extends Record<string, unknown> {
+  calendar?: string;
+  display_name?: string;
+  locale?: string;
+  is_24_hour_format?: boolean;
+  timezone?: string;
+}
+interface ResponseContext extends Record<string, unknown> {
+  type?: string;
+  cookies?: string[][] | Record<string, string>;
+  headers?: Record<string, string>;
+  status_code?: number;
+  body_size?: number;
+}
+interface TraceContext extends Record<string, unknown> {
+  data?: {
+    [key: string]: any;
+  };
+  op?: string;
+  parent_span_id?: string;
+  span_id: string;
+  status?: string;
+  tags?: {
+    [key: string]: Primitive;
+  };
+  trace_id: string;
+  origin?: SpanOrigin;
+  links?: SpanLinkJSON[];
+}
+interface CloudResourceContext extends Record<string, unknown> {
+  ['cloud.provider']?: string;
+  ['cloud.account.id']?: string;
+  ['cloud.region']?: string;
+  ['cloud.availability_zone']?: string;
+  ['cloud.platform']?: string;
+  ['host.id']?: string;
+  ['host.type']?: string;
+}
+interface ProfileContext extends Record<string, unknown> {
+  profile_id: string;
+}
+/**
+ * Used to buffer flag evaluation data on the current scope and attach it to
+ * error events. `values` should be initialized as empty ([]), and modifying
+ * directly is not recommended. Use the functions in @sentry/browser
+ * src/utils/featureFlags instead.
+ */
+interface FeatureFlagContext extends Record<string, unknown> {
+  values: FeatureFlag[];
+}
+//#endregion
+export { Context, Contexts, TraceContext };
+//# sourceMappingURL=context.d.ts.map

package/dist/node_modules/.pnpm/@sentry_core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/csp.d.ts

@@ -0,0 +1,19 @@
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/csp.d.ts
+interface LegacyCSPReport {
+  readonly 'csp-report': {
+    readonly 'document-uri'?: string;
+    readonly referrer?: string;
+    readonly 'blocked-uri'?: string;
+    readonly 'effective-directive'?: string;
+    readonly 'violated-directive'?: string;
+    readonly 'original-policy'?: string;
+    readonly disposition: 'enforce' | 'report' | 'reporting';
+    readonly 'status-code'?: number;
+    readonly status?: string;
+    readonly 'script-sample'?: string;
+    readonly sample?: string;
+  };
+}
+//#endregion
+export { LegacyCSPReport };
+//# sourceMappingURL=csp.d.ts.map

package/dist/node_modules/.pnpm/@sentry_core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/datacategory.d.ts

@@ -0,0 +1,5 @@
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/datacategory.d.ts
+type DataCategory = 'default' | 'error' | 'transaction' | 'replay' | 'security' | 'attachment' | 'session' | 'internal' | 'profile' | 'monitor' | 'feedback' | 'span' | 'log_item' | 'log_byte' | 'metric' | 'unknown';
+//#endregion
+export { DataCategory };
+//# sourceMappingURL=datacategory.d.ts.map