@m5kdev/web-ui 0.8.2 → 0.8.3

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

@@ -0,0 +1,30 @@
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/debugMeta.d.ts
+/**
+ * Holds meta information to customize the behavior of Sentry's server-side event processing.
+ **/
+interface DebugMeta {
+  images?: Array<DebugImage>;
+}
+type DebugImage = WasmDebugImage | SourceMapDebugImage | MachoDebugImage;
+interface WasmDebugImage {
+  type: 'wasm';
+  debug_id: string;
+  code_id?: string | null;
+  code_file: string;
+  debug_file?: string | null;
+}
+interface SourceMapDebugImage {
+  type: 'sourcemap';
+  code_file: string;
+  debug_id: string;
+}
+interface MachoDebugImage {
+  type: 'macho';
+  debug_id: string;
+  image_addr: string;
+  image_size?: number;
+  code_file?: string;
+}
+//#endregion
+export { DebugImage, DebugMeta };
+//# sourceMappingURL=debugMeta.d.mts.map

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

@@ -0,0 +1,23 @@
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/dsn.d.ts
+/** Supported Sentry transport protocols in a Dsn. */
+type DsnProtocol = 'http' | 'https';
+/** Primitive components of a Dsn. */
+interface DsnComponents {
+  /** Protocol used to connect to Sentry. */
+  protocol: DsnProtocol;
+  /** Public authorization key. */
+  publicKey?: string;
+  /** Private authorization key (deprecated, optional). */
+  pass?: string;
+  /** Hostname of the Sentry instance. */
+  host: string;
+  /** Port of the Sentry instance. */
+  port?: string;
+  /** Sub path/ */
+  path?: string;
+  /** Project ID */
+  projectId: string;
+}
+//#endregion
+export { DsnComponents };
+//# sourceMappingURL=dsn.d.mts.map

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

@@ -0,0 +1,153 @@
+import { AttachmentType } from "./attachment.mjs";
+import { SpanJSON } from "./span.mjs";
+import { SerializedCheckIn } from "./checkin.mjs";
+import { ClientReport } from "./clientreport.mjs";
+import { LegacyCSPReport } from "./csp.mjs";
+import { DsnComponents } from "./dsn.mjs";
+import { FeedbackEvent, UserFeedback } from "./feedback/sendFeedback.mjs";
+import { SerializedLogContainer } from "./log.mjs";
+import { SerializedMetricContainer } from "./metric.mjs";
+import { Profile, ProfileChunk } from "./profiling.mjs";
+import { ReplayEvent, ReplayRecordingData } from "./replay.mjs";
+import { SdkInfo } from "./sdkinfo.mjs";
+import { SerializedSession, SessionAggregates } from "./session.mjs";
+import { Event } from "./event.mjs";
+
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/envelope.d.ts
+type DynamicSamplingContext = {
+  trace_id: string;
+  public_key: DsnComponents['publicKey'];
+  sample_rate?: string;
+  release?: string;
+  environment?: string;
+  transaction?: string;
+  replay_id?: string;
+  sampled?: string;
+  sample_rand?: string;
+  org_id?: string;
+};
+type EnvelopeItemType = 'client_report' | 'user_report' | 'feedback' | 'session' | 'sessions' | 'transaction' | 'attachment' | 'event' | 'profile' | 'profile_chunk' | 'replay_event' | 'replay_recording' | 'check_in' | 'span' | 'log' | 'metric' | 'trace_metric' | 'raw_security';
+type BaseEnvelopeHeaders = {
+  [key: string]: unknown;
+  dsn?: string;
+  sdk?: SdkInfo;
+};
+type BaseEnvelopeItemHeaders = {
+  [key: string]: unknown;
+  type: EnvelopeItemType;
+  length?: number;
+};
+type BaseEnvelopeItem<ItemHeader, P> = [ItemHeader & BaseEnvelopeItemHeaders, P];
+type BaseEnvelope<EnvelopeHeader, Item> = [EnvelopeHeader & BaseEnvelopeHeaders, Array<Item & BaseEnvelopeItem<BaseEnvelopeItemHeaders, unknown>>];
+type EventItemHeaders = {
+  type: 'event' | 'transaction' | 'profile' | 'feedback';
+};
+type AttachmentItemHeaders = {
+  type: 'attachment';
+  length: number;
+  filename: string;
+  content_type?: string;
+  attachment_type?: AttachmentType;
+};
+type UserFeedbackItemHeaders = {
+  type: 'user_report';
+};
+type FeedbackItemHeaders = {
+  type: 'feedback';
+};
+type SessionItemHeaders = {
+  type: 'session';
+};
+type SessionAggregatesItemHeaders = {
+  type: 'sessions';
+};
+type ClientReportItemHeaders = {
+  type: 'client_report';
+};
+type ReplayEventItemHeaders = {
+  type: 'replay_event';
+};
+type ReplayRecordingItemHeaders = {
+  type: 'replay_recording';
+  length: number;
+};
+type CheckInItemHeaders = {
+  type: 'check_in';
+};
+type ProfileItemHeaders = {
+  type: 'profile';
+};
+type ProfileChunkItemHeaders = {
+  type: 'profile_chunk';
+};
+type SpanItemHeaders = {
+  type: 'span';
+};
+type LogContainerItemHeaders = {
+  type: 'log';
+  /**
+   * The number of log items in the container. This must be the same as the number of log items in the payload.
+   */
+  item_count: number;
+  /**
+   * The content type of the log items. This must be `application/vnd.sentry.items.log+json`.
+   */
+  content_type: 'application/vnd.sentry.items.log+json';
+};
+type MetricContainerItemHeaders = {
+  type: 'trace_metric';
+  item_count: number;
+  content_type: 'application/vnd.sentry.items.trace-metric+json';
+};
+type RawSecurityHeaders = {
+  type: 'raw_security';
+  sentry_release?: string;
+  sentry_environment?: string;
+};
+type EventItem = BaseEnvelopeItem<EventItemHeaders, Event>;
+type AttachmentItem = BaseEnvelopeItem<AttachmentItemHeaders, string | Uint8Array>;
+type UserFeedbackItem = BaseEnvelopeItem<UserFeedbackItemHeaders, UserFeedback>;
+type SessionItem = BaseEnvelopeItem<SessionItemHeaders, SerializedSession> | BaseEnvelopeItem<SessionAggregatesItemHeaders, SessionAggregates>;
+type ClientReportItem = BaseEnvelopeItem<ClientReportItemHeaders, ClientReport>;
+type CheckInItem = BaseEnvelopeItem<CheckInItemHeaders, SerializedCheckIn>;
+type ReplayEventItem = BaseEnvelopeItem<ReplayEventItemHeaders, ReplayEvent>;
+type ReplayRecordingItem = BaseEnvelopeItem<ReplayRecordingItemHeaders, ReplayRecordingData>;
+type FeedbackItem = BaseEnvelopeItem<FeedbackItemHeaders, FeedbackEvent>;
+type ProfileItem = BaseEnvelopeItem<ProfileItemHeaders, Profile>;
+type ProfileChunkItem = BaseEnvelopeItem<ProfileChunkItemHeaders, ProfileChunk>;
+type SpanItem = BaseEnvelopeItem<SpanItemHeaders, Partial<SpanJSON>>;
+type LogContainerItem = BaseEnvelopeItem<LogContainerItemHeaders, SerializedLogContainer>;
+type MetricContainerItem = BaseEnvelopeItem<MetricContainerItemHeaders, SerializedMetricContainer>;
+type RawSecurityItem = BaseEnvelopeItem<RawSecurityHeaders, LegacyCSPReport>;
+type EventEnvelopeHeaders = {
+  event_id: string;
+  sent_at: string;
+  trace?: Partial<DynamicSamplingContext>;
+};
+type SessionEnvelopeHeaders = {
+  sent_at: string;
+};
+type CheckInEnvelopeHeaders = {
+  trace?: DynamicSamplingContext;
+};
+type ClientReportEnvelopeHeaders = BaseEnvelopeHeaders;
+type ReplayEnvelopeHeaders = BaseEnvelopeHeaders;
+type SpanEnvelopeHeaders = BaseEnvelopeHeaders & {
+  trace?: DynamicSamplingContext;
+};
+type LogEnvelopeHeaders = BaseEnvelopeHeaders;
+type MetricEnvelopeHeaders = BaseEnvelopeHeaders;
+type EventEnvelope = BaseEnvelope<EventEnvelopeHeaders, EventItem | AttachmentItem | UserFeedbackItem | FeedbackItem | ProfileItem>;
+type SessionEnvelope = BaseEnvelope<SessionEnvelopeHeaders, SessionItem>;
+type ClientReportEnvelope = BaseEnvelope<ClientReportEnvelopeHeaders, ClientReportItem>;
+type ReplayEnvelope = [ReplayEnvelopeHeaders, [ReplayEventItem, ReplayRecordingItem]];
+type CheckInEnvelope = BaseEnvelope<CheckInEnvelopeHeaders, CheckInItem>;
+type SpanEnvelope = BaseEnvelope<SpanEnvelopeHeaders, SpanItem>;
+type ProfileChunkEnvelope = BaseEnvelope<BaseEnvelopeHeaders, ProfileChunkItem>;
+type RawSecurityEnvelope = BaseEnvelope<BaseEnvelopeHeaders, RawSecurityItem>;
+type LogEnvelope = BaseEnvelope<LogEnvelopeHeaders, LogContainerItem>;
+type MetricEnvelope = BaseEnvelope<MetricEnvelopeHeaders, MetricContainerItem>;
+type Envelope = EventEnvelope | SessionEnvelope | ClientReportEnvelope | ProfileChunkEnvelope | ReplayEnvelope | CheckInEnvelope | SpanEnvelope | RawSecurityEnvelope | LogEnvelope | MetricEnvelope;
+//#endregion
+export { DynamicSamplingContext, Envelope };
+//# sourceMappingURL=envelope.d.mts.map

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

@@ -0,0 +1,91 @@
+import { Attachment } from "./attachment.mjs";
+import { SeverityLevel } from "./severity.mjs";
+import { Breadcrumb } from "./breadcrumb.mjs";
+import { Measurements } from "./measurement.mjs";
+import { TransactionSource } from "./transaction.mjs";
+import { SpanJSON } from "./span.mjs";
+import { RequestEventData } from "./request.mjs";
+import { Primitive } from "./misc.mjs";
+import { Contexts } from "./context.mjs";
+import { User } from "./user.mjs";
+import { DebugMeta } from "./debugMeta.mjs";
+import { SdkInfo } from "./sdkinfo.mjs";
+import { Extras } from "./extra.mjs";
+import { CaptureContext, SdkProcessingMetadata } from "../scope.mjs";
+import { Mechanism } from "./mechanism.mjs";
+import { Exception } from "./exception.mjs";
+import { Thread } from "./thread.mjs";
+
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/event.d.ts
+/** An event to be sent to Sentry. */
+interface Event {
+  event_id?: string;
+  message?: string;
+  logentry?: {
+    message?: string;
+    params?: unknown[];
+  };
+  timestamp?: number;
+  start_timestamp?: number;
+  level?: SeverityLevel;
+  platform?: string;
+  logger?: string;
+  server_name?: string;
+  release?: string;
+  dist?: string;
+  environment?: string;
+  sdk?: SdkInfo;
+  request?: RequestEventData;
+  transaction?: string;
+  modules?: {
+    [key: string]: string;
+  };
+  fingerprint?: string[];
+  exception?: {
+    values?: Exception[];
+  };
+  breadcrumbs?: Breadcrumb[];
+  contexts?: Contexts;
+  tags?: {
+    [key: string]: Primitive;
+  };
+  extra?: Extras;
+  user?: User;
+  type?: EventType;
+  spans?: SpanJSON[];
+  measurements?: Measurements;
+  debug_meta?: DebugMeta;
+  sdkProcessingMetadata?: SdkProcessingMetadata;
+  transaction_info?: {
+    source: TransactionSource;
+  };
+  threads?: {
+    values: Thread[];
+  };
+}
+/**
+ * The type of an `Event`.
+ * Note that `ErrorEvent`s do not have a type (hence its undefined),
+ * while all other events are required to have one.
+ */
+type EventType = 'transaction' | 'profile' | 'replay_event' | 'feedback' | undefined;
+interface ErrorEvent extends Event {
+  type: undefined;
+}
+interface TransactionEvent extends Event {
+  type: 'transaction';
+}
+/** JSDoc */
+interface EventHint {
+  event_id?: string;
+  captureContext?: CaptureContext;
+  mechanism?: Partial<Mechanism>;
+  syntheticException?: Error | null;
+  originalException?: unknown;
+  attachments?: Attachment[];
+  data?: any;
+  integrations?: string[];
+}
+//#endregion
+export { ErrorEvent, Event, EventHint, TransactionEvent };
+//# sourceMappingURL=event.d.mts.map

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

@@ -0,0 +1,16 @@
+import { Event, EventHint } from "./event.mjs";
+
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/eventprocessor.d.ts
+/**
+ * Event processors are used to change the event before it will be sent.
+ * We strongly advise to make this function sync.
+ * Returning a PromiseLike<Event | null> will work just fine, but better be sure that you know what you are doing.
+ * Event processing will be deferred until your Promise is resolved.
+ */
+interface EventProcessor {
+  (event: Event, hint: EventHint): PromiseLike<Event | null> | Event | null;
+  id?: string;
+}
+//#endregion
+export { EventProcessor };
+//# sourceMappingURL=eventprocessor.d.mts.map

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

@@ -0,0 +1,16 @@
+import { Mechanism } from "./mechanism.mjs";
+import { Stacktrace } from "./stacktrace.mjs";
+
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/exception.d.ts
+/** JSDoc */
+interface Exception {
+  type?: string;
+  value?: string;
+  mechanism?: Mechanism;
+  module?: string;
+  thread_id?: number | string;
+  stacktrace?: Stacktrace;
+}
+//#endregion
+export { Exception };
+//# sourceMappingURL=exception.d.mts.map

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

@@ -0,0 +1,6 @@
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/extra.d.ts
+type Extra = unknown;
+type Extras = Record<string, Extra>;
+//#endregion
+export { Extra, Extras };
+//# sourceMappingURL=extra.d.mts.map

package/dist/node_modules/.pnpm/@sentry_core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/feedback/sendFeedback.d.mts

@@ -0,0 +1,35 @@
+import { User } from "../user.mjs";
+import { Event } from "../event.mjs";
+
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/feedback/sendFeedback.d.ts
+/**
+ * Crash report feedback object
+ */
+interface UserFeedback {
+  event_id: string;
+  email: User['email'];
+  name: string;
+  comments: string;
+}
+interface FeedbackContext extends Record<string, unknown> {
+  message: string;
+  contact_email?: string;
+  name?: string;
+  replay_id?: string;
+  url?: string;
+  associated_event_id?: string;
+  source?: string;
+}
+/**
+ * NOTE: These types are still considered Alpha and subject to change.
+ * @hidden
+ */
+interface FeedbackEvent extends Event {
+  type: 'feedback';
+  contexts: Event['contexts'] & {
+    feedback: FeedbackContext;
+  };
+}
+//#endregion
+export { FeedbackEvent, UserFeedback };
+//# sourceMappingURL=sendFeedback.d.mts.map

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

@@ -0,0 +1,43 @@
+import { Event, EventHint } from "./event.mjs";
+import { Client } from "../client.mjs";
+
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/integration.d.ts
+/** Integration interface */
+interface Integration {
+  /**
+   * The name of the integration.
+   */
+  name: string;
+  /**
+   * This hook is only called once, even if multiple clients are created.
+   * It does not receives any arguments, and should only use for e.g. global monkey patching and similar things.
+   */
+  setupOnce?(): void;
+  /**
+   * Set up an integration for the given client.
+   * Receives the client as argument.
+   *
+   * Whenever possible, prefer this over `setupOnce`, as that is only run for the first client,
+   * whereas `setup` runs for each client. Only truly global things (e.g. registering global handlers)
+   * should be done in `setupOnce`.
+   */
+  setup?(client: Client): void;
+  /**
+   * This hook is triggered after `setupOnce()` and `setup()` have been called for all integrations.
+   * You can use it if it is important that all other integrations have been run before.
+   */
+  afterAllSetup?(client: Client): void;
+  /**
+   * An optional hook that allows to preprocess an event _before_ it is passed to all other event processors.
+   */
+  preprocessEvent?(event: Event, hint: EventHint | undefined, client: Client): void;
+  /**
+   * An optional hook that allows to process an event.
+   * Return `null` to drop the event, or mutate the event & return it.
+   * This receives the client that the integration was installed for as third argument.
+   */
+  processEvent?(event: Event, hint: EventHint, client: Client): Event | null | PromiseLike<Event | null>;
+}
+//#endregion
+export { Integration };
+//# sourceMappingURL=integration.d.mts.map

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

@@ -0,0 +1,32 @@
+import { SpanAttributeValue, SpanContextData } from "./span.mjs";
+
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/link.d.ts
+type SpanLinkAttributes = {
+  /**
+   * Setting the link type to 'previous_trace' helps the Sentry product linking to the previous trace
+   */
+  'sentry.link.type'?: string | 'previous_trace';
+} & Record<string, SpanAttributeValue | undefined>;
+interface SpanLink {
+  /**
+   * Contains the SpanContext of the span to link to
+   */
+  context: SpanContextData;
+  /**
+   * A key-value pair with primitive values or an array of primitive values
+   */
+  attributes?: SpanLinkAttributes;
+}
+/**
+ * Link interface for the event envelope item. It's a flattened representation of `SpanLink`.
+ * Can include additional fields defined by OTel.
+ */
+interface SpanLinkJSON extends Record<string, unknown> {
+  span_id: string;
+  trace_id: string;
+  sampled?: boolean;
+  attributes?: SpanLinkAttributes;
+}
+//#endregion
+export { SpanLink, SpanLinkJSON };
+//# sourceMappingURL=link.d.mts.map

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

@@ -0,0 +1,73 @@
+import { ParameterizedString } from "./parameterize.mjs";
+
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/log.d.ts
+type LogSeverityLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+interface Log {
+  /**
+   * The severity level of the log.
+   *
+   * Allowed values are, from highest to lowest:
+   * `critical`, `fatal`, `error`, `warn`, `info`, `debug`, `trace`.
+   *
+   * The log level changes how logs are filtered and displayed.
+   * Critical level logs are emphasized more than trace level logs.
+   */
+  level: LogSeverityLevel;
+  /**
+   * The message to be logged.
+   */
+  message: ParameterizedString;
+  /**
+   * Arbitrary structured data that stores information about the log - e.g., userId: 100.
+   */
+  attributes?: Record<string, unknown>;
+  /**
+   * The severity number.
+   */
+  severityNumber?: number;
+}
+type SerializedLogAttributeValue = {
+  value: string;
+  type: 'string';
+} | {
+  value: number;
+  type: 'integer';
+} | {
+  value: number;
+  type: 'double';
+} | {
+  value: boolean;
+  type: 'boolean';
+};
+interface SerializedLog {
+  /**
+   * Timestamp in seconds (epoch time) indicating when the  log occurred.
+   */
+  timestamp: number;
+  /**
+   * The severity level of the log. One of `trace`, `debug`, `info`, `warn`, `error`, `fatal`.
+   */
+  level: LogSeverityLevel;
+  /**
+   * The log body.
+   */
+  body: Log['message'];
+  /**
+   * The trace ID for this log
+   */
+  trace_id?: string;
+  /**
+   * Arbitrary structured data that stores information about the log - e.g., userId: 100.
+   */
+  attributes?: Record<string, SerializedLogAttributeValue>;
+  /**
+   * The severity number.
+   */
+  severity_number?: Log['severityNumber'];
+}
+type SerializedLogContainer = {
+  items: Array<SerializedLog>;
+};
+//#endregion
+export { Log, SerializedLogContainer };
+//# sourceMappingURL=log.d.mts.map

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

@@ -0,0 +1,26 @@
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/measurement.d.ts
+/**
+ * A time duration.
+ */
+type DurationUnit = 'nanosecond' | 'microsecond' | 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'week';
+/**
+ * Size of information derived from bytes.
+ */
+type InformationUnit = 'bit' | 'byte' | 'kilobyte' | 'kibibyte' | 'megabyte' | 'mebibyte' | 'gigabyte' | 'terabyte' | 'tebibyte' | 'petabyte' | 'exabyte' | 'exbibyte';
+/**
+ * Fractions such as percentages.
+ */
+type FractionUnit = 'ratio' | 'percent';
+/**
+ * Untyped value without a unit.
+ */
+type NoneUnit = '' | 'none';
+type LiteralUnion<T extends string> = T | Omit<T, T>;
+type MeasurementUnit = LiteralUnion<DurationUnit | InformationUnit | FractionUnit | NoneUnit>;
+type Measurements = Record<string, {
+  value: number;
+  unit: MeasurementUnit;
+}>;
+//#endregion
+export { MeasurementUnit, Measurements };
+//# sourceMappingURL=measurement.d.mts.map

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

@@ -0,0 +1,54 @@
+//#region ../../node_modules/.pnpm/@sentry+core@10.22.0/node_modules/@sentry/core/build/types/types-hoist/mechanism.d.ts
+/**
+ * Metadata about a captured exception, intended to provide a hint as to the means by which it was captured.
+ */
+interface Mechanism {
+  /**
+   * For now, restricted to `onerror`, `onunhandledrejection` (both obvious), `instrument` (the result of
+   * auto-instrumentation), and `generic` (everything else). Converted to a tag on ingest.
+   */
+  type: string;
+  /**
+   * In theory, whether or not the exception has been handled by the user. In practice, whether or not we see it before
+   * it hits the global error/rejection handlers, whether through explicit handling by the user or auto instrumentation.
+   * Converted to a tag on ingest and used in various ways in the UI.
+   */
+  handled?: boolean;
+  /**
+   * Arbitrary data to be associated with the mechanism (for example, errors coming from event handlers include the
+   * handler name and the event target. Will show up in the UI directly above the stacktrace.
+   */
+  data?: {
+    [key: string]: string | boolean;
+  };
+  /**
+   * True when `captureException` is called with anything other than an instance of `Error` (or, in the case of browser,
+   * an instance of `ErrorEvent`, `DOMError`, or `DOMException`). causing us to create a synthetic error in an attempt
+   * to recreate the stacktrace.
+   */
+  synthetic?: boolean;
+  /**
+   * Describes the source of the exception, in the case that this is a derived (linked or aggregate) error.
+   *
+   * This should be populated with the name of the property where the exception was found on the parent exception.
+   * E.g. "cause", "errors[0]", "errors[1]"
+   */
+  source?: string;
+  /**
+   * Indicates whether the exception is an `AggregateException`.
+   */
+  is_exception_group?: boolean;
+  /**
+   * An identifier for the exception inside the `event.exception.values` array. This identifier is referenced to via the
+   * `parent_id` attribute to link and aggregate errors.
+   */
+  exception_id?: number;
+  /**
+   * References another exception via the `exception_id` field to indicate that this exception is a child of that
+   * exception in the case of aggregate or linked errors.
+   */
+  parent_id?: number;
+}
+//#endregion
+export { Mechanism };
+//# sourceMappingURL=mechanism.d.mts.map