diff --git a/packages/replay/src/coreHandlers/handleScope.ts b/packages/replay/src/coreHandlers/handleScope.ts
index 8f937b140882..78d0b6dd3fd3 100644
--- a/packages/replay/src/coreHandlers/handleScope.ts
+++ b/packages/replay/src/coreHandlers/handleScope.ts
@@ -3,12 +3,19 @@ import { normalize } from '@sentry/utils';
 
 import { CONSOLE_ARG_MAX_SIZE } from '../constants';
 import type { ReplayContainer } from '../types';
+import type { ReplayFrame } from '../types/replayFrame';
 import { createBreadcrumb } from '../util/createBreadcrumb';
 import { fixJson } from '../util/truncateJson/fixJson';
 import { addBreadcrumbEvent } from './util/addBreadcrumbEvent';
 
 let _LAST_BREADCRUMB: null | Breadcrumb = null;
 
+type BreadcrumbWithCategory = Required<Pick<Breadcrumb, 'category'>>;
+
+function isBreadcrumbWithCategory(breadcrumb: Breadcrumb): breadcrumb is BreadcrumbWithCategory {
+  return !!breadcrumb.category;
+}
+
 export const handleScopeListener: (replay: ReplayContainer) => (scope: Scope) => void =
   (replay: ReplayContainer) =>
   (scope: Scope): void => {
@@ -44,9 +51,9 @@ export function handleScope(scope: Scope): Breadcrumb | null {
   _LAST_BREADCRUMB = newBreadcrumb;
 
   if (
-    newBreadcrumb.category &&
-    (['fetch', 'xhr', 'sentry.event', 'sentry.transaction'].includes(newBreadcrumb.category) ||
-      newBreadcrumb.category.startsWith('ui.'))
+    !isBreadcrumbWithCategory(newBreadcrumb) ||
+    ['fetch', 'xhr', 'sentry.event', 'sentry.transaction'].includes(newBreadcrumb.category) ||
+    newBreadcrumb.category.startsWith('ui.')
   ) {
     return null;
   }
@@ -59,7 +66,9 @@ export function handleScope(scope: Scope): Breadcrumb | null {
 }
 
 /** exported for tests only */
-export function normalizeConsoleBreadcrumb(breadcrumb: Breadcrumb): Breadcrumb {
+export function normalizeConsoleBreadcrumb(
+  breadcrumb: Omit<Breadcrumb, 'category'> & BreadcrumbWithCategory,
+): ReplayFrame {
   const args = breadcrumb.data && breadcrumb.data.arguments;
 
   if (!Array.isArray(args) || args.length === 0) {
diff --git a/packages/replay/src/index.ts b/packages/replay/src/index.ts
index 0baefd4e9c37..239cd727d67f 100644
--- a/packages/replay/src/index.ts
+++ b/packages/replay/src/index.ts
@@ -1 +1,9 @@
 export { Replay } from './integration';
+export type {
+  BreadcrumbFrame,
+  BreadcrumbFrameEvent,
+  ReplayFrame,
+  ReplayFrameEvent,
+  SpanFrame,
+  SpanFrameEvent,
+} from './types/replayFrame';
diff --git a/packages/replay/src/replay.ts b/packages/replay/src/replay.ts
index 4d5c918b7610..e6f7e2128538 100644
--- a/packages/replay/src/replay.ts
+++ b/packages/replay/src/replay.ts
@@ -1,7 +1,7 @@
 /* eslint-disable max-lines */ // TODO: We might want to split this file up
 import { EventType, record } from '@sentry-internal/rrweb';
 import { captureException, getCurrentHub } from '@sentry/core';
-import type { Breadcrumb, ReplayRecordingMode, Transaction } from '@sentry/types';
+import type { ReplayRecordingMode, Transaction } from '@sentry/types';
 import { logger } from '@sentry/utils';
 
 import {
@@ -21,6 +21,7 @@ import type {
   AddEventResult,
   AddUpdateCallback,
   AllPerformanceEntry,
+  BreadcrumbFrame,
   EventBuffer,
   InternalEventContext,
   PopEventContext,
@@ -808,7 +809,7 @@ export class ReplayContainer implements ReplayContainerInterface {
   /**
    * Tasks to run when we consider a page to be hidden (via blurring and/or visibility)
    */
-  private _doChangeToBackgroundTasks(breadcrumb?: Breadcrumb): void {
+  private _doChangeToBackgroundTasks(breadcrumb?: BreadcrumbFrame): void {
     if (!this.session) {
       return;
     }
@@ -828,7 +829,7 @@ export class ReplayContainer implements ReplayContainerInterface {
   /**
    * Tasks to run when we consider a page to be visible (via focus and/or visibility)
    */
-  private _doChangeToForegroundTasks(breadcrumb?: Breadcrumb): void {
+  private _doChangeToForegroundTasks(breadcrumb?: BreadcrumbFrame): void {
     if (!this.session) {
       return;
     }
@@ -881,7 +882,7 @@ export class ReplayContainer implements ReplayContainerInterface {
   /**
    * Helper to create (and buffer) a replay breadcrumb from a core SDK breadcrumb
    */
-  private _createCustomBreadcrumb(breadcrumb: Breadcrumb): void {
+  private _createCustomBreadcrumb(breadcrumb: BreadcrumbFrame): void {
     this.addUpdate(() => {
       void this.throttledAddEvent({
         type: EventType.Custom,
diff --git a/packages/replay/src/types/index.ts b/packages/replay/src/types/index.ts
new file mode 100644
index 000000000000..2461e4f3ac8e
--- /dev/null
+++ b/packages/replay/src/types/index.ts
@@ -0,0 +1,4 @@
+export * from './performance';
+export * from './replay';
+export * from './replayFrame';
+export * from './rrweb';
diff --git a/packages/replay/src/types/performance.ts b/packages/replay/src/types/performance.ts
new file mode 100644
index 000000000000..0ff647e7d7d0
--- /dev/null
+++ b/packages/replay/src/types/performance.ts
@@ -0,0 +1,160 @@
+export type AllPerformanceEntry = PerformancePaintTiming | PerformanceResourceTiming | PerformanceNavigationTiming;
+
+// PerformancePaintTiming and PerformanceNavigationTiming are only available with TS 4.4 and newer
+// Therefore, we're exporting them here to make them available in older TS versions
+export type PerformancePaintTiming = PerformanceEntry;
+export type PerformanceNavigationTiming = PerformanceEntry &
+  PerformanceResourceTiming & {
+    type: string;
+    transferSize: number;
+
+    /**
+     * A DOMHighResTimeStamp representing the time immediately before the user agent
+     * sets the document's readyState to "interactive".
+     */
+    domInteractive: number;
+
+    /**
+     * A DOMHighResTimeStamp representing the time immediately before the current
+     * document's DOMContentLoaded event handler starts.
+     */
+    domContentLoadedEventStart: number;
+    /**
+     * A DOMHighResTimeStamp representing the time immediately after the current
+     * document's DOMContentLoaded event handler completes.
+     */
+    domContentLoadedEventEnd: number;
+
+    /**
+     * A DOMHighResTimeStamp representing the time immediately before the current
+     * document's load event handler starts.
+     */
+    loadEventStart: number;
+
+    /**
+     * A DOMHighResTimeStamp representing the time immediately after the current
+     * document's load event handler completes.
+     */
+    loadEventEnd: number;
+
+    /**
+     * A DOMHighResTimeStamp representing the time immediately before the user agent
+     * sets the document's readyState to "complete".
+     */
+    domComplete: number;
+
+    /**
+     * A number representing the number of redirects since the last non-redirect
+     * navigation in the current browsing context.
+     */
+    redirectCount: number;
+  };
+export type ExperimentalPerformanceResourceTiming = PerformanceResourceTiming & {
+  // Experimental, see: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/responseStatus
+  // Requires Chrome 109
+  responseStatus?: number;
+};
+
+export type PaintData = undefined;
+
+/**
+ * See https://developer.mozilla.org/en-US/docs/Web/API/PerformanceNavigationTiming
+ *
+ * Note `navigation.push` will not have any data
+ */
+export type NavigationData = Partial<
+  Pick<
+    PerformanceNavigationTiming,
+    | 'decodedBodySize'
+    | 'encodedBodySize'
+    | 'duration'
+    | 'domInteractive'
+    | 'domContentLoadedEventEnd'
+    | 'domContentLoadedEventStart'
+    | 'loadEventStart'
+    | 'loadEventEnd'
+    | 'domComplete'
+    | 'redirectCount'
+  >
+> & {
+  /**
+   * Transfer size of resource
+   */
+  size?: number;
+};
+
+export type ResourceData = Pick<PerformanceResourceTiming, 'decodedBodySize' | 'encodedBodySize'> & {
+  /**
+   * Transfer size of resource
+   */
+  size: number;
+  /**
+   * HTTP status code. Note this is experimental and not available on all browsers.
+   */
+  statusCode?: number;
+};
+
+export interface LargestContentfulPaintData {
+  /**
+   * Render time (in ms) of the LCP
+   */
+  value: number;
+  size: number;
+  /**
+   * The recording id of the LCP node. -1 if not found
+   */
+  nodeId?: number;
+}
+
+/**
+ * Entries that come from window.performance
+ */
+export type AllPerformanceEntryData = PaintData | NavigationData | ResourceData | LargestContentfulPaintData;
+
+export interface MemoryData {
+  memory: {
+    jsHeapSizeLimit: number;
+    totalJSHeapSize: number;
+    usedJSHeapSize: number;
+  };
+}
+
+export interface NetworkRequestData {
+  method?: string;
+  statusCode?: number;
+  requestBodySize?: number;
+  responseBodySize?: number;
+}
+
+export interface HistoryData {
+  previous: string;
+}
+
+export type AllEntryData = AllPerformanceEntryData | MemoryData | NetworkRequestData | HistoryData;
+
+export interface ReplayPerformanceEntry<T> {
+  /**
+   * One of these types https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry/entryType
+   */
+  type: string;
+
+  /**
+   * A more specific description of the performance entry
+   */
+  name: string;
+
+  /**
+   * The start timestamp in seconds
+   */
+  start: number;
+
+  /**
+   * The end timestamp in seconds
+   */
+  end: number;
+
+  /**
+   * Additional unstructured data to be included
+   */
+  data: T;
+}
diff --git a/packages/replay/src/types.ts b/packages/replay/src/types/replay.ts
similarity index 73%
rename from packages/replay/src/types.ts
rename to packages/replay/src/types/replay.ts
index f52c163f6e69..262dcbf65a88 100644
--- a/packages/replay/src/types.ts
+++ b/packages/replay/src/types/replay.ts
@@ -8,14 +8,14 @@ import type {
   XhrBreadcrumbHint,
 } from '@sentry/types';
 
-import type { eventWithTime, recordOptions } from './types/rrweb';
-import type { SKIPPED, THROTTLED } from './util/throttle';
+import type { SKIPPED, THROTTLED } from '../util/throttle';
+import type { AllPerformanceEntry } from './performance';
+import type { ReplayFrameEvent } from './replayFrame';
+import type { eventWithTime, recordOptions } from './rrweb';
 
-export type RecordingEvent = eventWithTime;
+export type RecordingEvent = ReplayFrameEvent | eventWithTime;
 export type RecordingOptions = recordOptions;
 
-export type AllPerformanceEntry = PerformancePaintTiming | PerformanceResourceTiming | PerformanceNavigationTiming;
-
 export interface SendReplayData {
   recordingData: ReplayRecordingData;
   replayId: string;
@@ -41,138 +41,6 @@ export interface WorkerRequest {
   arg?: string;
 }
 
-// PerformancePaintTiming and PerformanceNavigationTiming are only available with TS 4.4 and newer
-// Therefore, we're exporting them here to make them available in older TS versions
-export type PerformancePaintTiming = PerformanceEntry;
-export type PerformanceNavigationTiming = PerformanceEntry &
-  PerformanceResourceTiming & {
-    type: string;
-    transferSize: number;
-
-    /**
-     * A DOMHighResTimeStamp representing the time immediately before the user agent
-     * sets the document's readyState to "interactive".
-     */
-    domInteractive: number;
-
-    /**
-     * A DOMHighResTimeStamp representing the time immediately before the current
-     * document's DOMContentLoaded event handler starts.
-     */
-    domContentLoadedEventStart: number;
-    /**
-     * A DOMHighResTimeStamp representing the time immediately after the current
-     * document's DOMContentLoaded event handler completes.
-     */
-    domContentLoadedEventEnd: number;
-
-    /**
-     * A DOMHighResTimeStamp representing the time immediately before the current
-     * document's load event handler starts.
-     */
-    loadEventStart: number;
-
-    /**
-     * A DOMHighResTimeStamp representing the time immediately after the current
-     * document's load event handler completes.
-     */
-    loadEventEnd: number;
-
-    /**
-     * A DOMHighResTimeStamp representing the time immediately before the user agent
-     * sets the document's readyState to "complete".
-     */
-    domComplete: number;
-
-    /**
-     * A number representing the number of redirects since the last non-redirect
-     * navigation in the current browsing context.
-     */
-    redirectCount: number;
-  };
-export type ExperimentalPerformanceResourceTiming = PerformanceResourceTiming & {
-  // Experimental, see: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/responseStatus
-  // Requires Chrome 109
-  responseStatus?: number;
-};
-
-export type PaintData = undefined;
-
-/**
- * See https://developer.mozilla.org/en-US/docs/Web/API/PerformanceNavigationTiming
- *
- * Note `navigation.push` will not have any data
- */
-export type NavigationData = Partial<
-  Pick<
-    PerformanceNavigationTiming,
-    | 'decodedBodySize'
-    | 'encodedBodySize'
-    | 'duration'
-    | 'domInteractive'
-    | 'domContentLoadedEventEnd'
-    | 'domContentLoadedEventStart'
-    | 'loadEventStart'
-    | 'loadEventEnd'
-    | 'domComplete'
-    | 'redirectCount'
-  >
-> & {
-  /**
-   * Transfer size of resource
-   */
-  size?: number;
-};
-
-export type ResourceData = Pick<PerformanceResourceTiming, 'decodedBodySize' | 'encodedBodySize'> & {
-  /**
-   * Transfer size of resource
-   */
-  size: number;
-  /**
-   * HTTP status code. Note this is experimental and not available on all browsers.
-   */
-  statusCode?: number;
-};
-
-export interface LargestContentfulPaintData {
-  /**
-   * Render time (in ms) of the LCP
-   */
-  value: number;
-  size: number;
-  /**
-   * The recording id of the LCP node. -1 if not found
-   */
-  nodeId?: number;
-}
-
-/**
- * Entries that come from window.performance
- */
-export type AllPerformanceEntryData = PaintData | NavigationData | ResourceData | LargestContentfulPaintData;
-
-export interface MemoryData {
-  memory: {
-    jsHeapSizeLimit: number;
-    totalJSHeapSize: number;
-    usedJSHeapSize: number;
-  };
-}
-
-export interface NetworkRequestData {
-  method?: string;
-  statusCode?: number;
-  requestBodySize?: number;
-  responseBodySize?: number;
-}
-
-export interface HistoryData {
-  previous: string;
-}
-
-export type AllEntryData = AllPerformanceEntryData | MemoryData | NetworkRequestData | HistoryData;
-
 /**
  * The response from the worker
  */
@@ -186,7 +54,7 @@ export interface WorkerResponse {
 export type AddEventResult = void;
 
 export interface BeforeAddRecordingEvent {
-  (event: RecordingEvent): RecordingEvent | null | undefined;
+  (event: ReplayFrameEvent): ReplayFrameEvent | null | undefined;
 }
 
 export interface ReplayNetworkOptions {
@@ -565,33 +433,6 @@ export interface ReplayContainer {
   getCurrentRoute(): string | undefined;
 }
 
-export interface ReplayPerformanceEntry<T> {
-  /**
-   * One of these types https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry/entryType
-   */
-  type: string;
-
-  /**
-   * A more specific description of the performance entry
-   */
-  name: string;
-
-  /**
-   * The start timestamp in seconds
-   */
-  start: number;
-
-  /**
-   * The end timestamp in seconds
-   */
-  end: number;
-
-  /**
-   * Additional unstructured data to be included
-   */
-  data: T;
-}
-
 type RequestBody = null | Blob | BufferSource | FormData | URLSearchParams | string;
 
 export type XhrHint = XhrBreadcrumbHint & {
diff --git a/packages/replay/src/types/replayFrame.ts b/packages/replay/src/types/replayFrame.ts
new file mode 100644
index 000000000000..463e462851e6
--- /dev/null
+++ b/packages/replay/src/types/replayFrame.ts
@@ -0,0 +1,174 @@
+import type { Breadcrumb, FetchBreadcrumbData, XhrBreadcrumbData } from '@sentry/types';
+
+import type { AllEntryData } from './performance';
+import type { EventType } from './rrweb';
+
+interface BaseReplayFrame {
+  timestamp: number;
+  /**
+   * For compatibility reasons
+   */
+  type: string;
+  category: string;
+  data?: Record<string, any>;
+  message?: string;
+}
+
+interface BaseDomFrameData {
+  nodeId?: number;
+  node?: {
+    id: number;
+    tagName: string;
+    textContent: string;
+    attributes: Record<string, any>;
+  };
+}
+
+/* Breadcrumbs from Core SDK */
+interface ConsoleFrameData {
+  logger: string;
+  arguments?: unknown[];
+}
+interface ConsoleFrame extends BaseReplayFrame {
+  category: 'console';
+  level: Breadcrumb['level'];
+  message: string;
+  data: ConsoleFrameData;
+}
+
+type ClickFrameData = BaseDomFrameData;
+interface ClickFrame extends BaseReplayFrame {
+  category: 'ui.click';
+  message: string;
+  data: ClickFrameData;
+}
+
+interface FetchFrame extends BaseReplayFrame {
+  category: 'fetch';
+  type: 'http';
+  data: FetchBreadcrumbData;
+}
+
+interface InputFrame extends BaseReplayFrame {
+  category: 'ui.input';
+  message: string;
+}
+
+interface XhrFrame extends BaseReplayFrame {
+  category: 'xhr';
+  type: 'http';
+  data: XhrBreadcrumbData;
+}
+
+/* Breadcrumbs from Replay */
+interface MutationFrameData {
+  count: number;
+  limit: boolean;
+}
+interface MutationFrame extends BaseReplayFrame {
+  category: 'replay.mutations';
+  data: MutationFrameData;
+}
+
+interface KeyboardEventFrameData extends BaseDomFrameData {
+  metaKey: boolean;
+  shiftKey: boolean;
+  ctrlKey: boolean;
+  altKey: boolean;
+  key: string;
+}
+interface KeyboardEventFrame extends BaseReplayFrame {
+  category: 'ui.keyDown';
+  data: KeyboardEventFrameData;
+}
+
+interface BlurFrame extends BaseReplayFrame {
+  category: 'ui.blur';
+}
+
+interface FocusFrame extends BaseReplayFrame {
+  category: 'ui.focus';
+}
+
+interface SlowClickFrameData extends ClickFrameData {
+  url: string;
+  timeAfterClickFs: number;
+  endReason: string;
+}
+interface SlowClickFrame extends BaseReplayFrame {
+  category: 'ui.slowClickDetected';
+  data: SlowClickFrameData;
+}
+
+interface OptionFrame {
+  sessionSampleRate: number;
+  errorSampleRate: number;
+  useCompressionOption: boolean;
+  blockAllMedia: boolean;
+  maskAllText: boolean;
+  maskAllInputs: boolean;
+  useCompression: boolean;
+  networkDetailHasUrls: boolean;
+  networkCaptureBodies: boolean;
+  networkRequestHasHeaders: boolean;
+  networkResponseHasHeaders: boolean;
+}
+
+export type BreadcrumbFrame =
+  | ConsoleFrame
+  | ClickFrame
+  | FetchFrame
+  | InputFrame
+  | XhrFrame
+  | KeyboardEventFrame
+  | BlurFrame
+  | FocusFrame
+  | SlowClickFrame
+  | MutationFrame
+  | BaseReplayFrame;
+
+export interface SpanFrame {
+  op: string;
+  description: string;
+  startTimestamp: number;
+  endTimestamp: number;
+  data: AllEntryData;
+}
+
+export type ReplayFrame = BreadcrumbFrame | SpanFrame;
+
+interface RecordingCustomEvent {
+  type: EventType.Custom;
+  timestamp: number;
+  data: {
+    tag: string;
+    payload: unknown;
+  };
+}
+
+export interface BreadcrumbFrameEvent extends RecordingCustomEvent {
+  data: {
+    tag: 'breadcrumb';
+    payload: BreadcrumbFrame;
+    /**
+     * This will indicate to backend to additionally log as a metric
+     */
+    metric?: boolean;
+  };
+}
+
+export interface SpanFrameEvent extends RecordingCustomEvent {
+  data: {
+    tag: 'performanceSpan';
+    payload: SpanFrame;
+  };
+}
+
+export interface OptionFrameEvent extends RecordingCustomEvent {
+  data: {
+    tag: 'options';
+    payload: OptionFrame;
+  };
+}
+
+export type ReplayFrameEvent = BreadcrumbFrameEvent | SpanFrameEvent | OptionFrameEvent;
diff --git a/packages/replay/src/util/addEvent.ts b/packages/replay/src/util/addEvent.ts
index e40a9c2f6486..2a5458887af6 100644
--- a/packages/replay/src/util/addEvent.ts
+++ b/packages/replay/src/util/addEvent.ts
@@ -1,10 +1,14 @@
 import { getCurrentHub } from '@sentry/core';
 import { logger } from '@sentry/utils';
 
-import type { AddEventResult, RecordingEvent, ReplayContainer } from '../types';
+import type { AddEventResult, RecordingEvent, ReplayContainer, ReplayFrameEvent } from '../types';
 import { EventType } from '../types/rrweb';
 import { timestampToMs } from './timestampToMs';
 
+function isCustomEvent(event: RecordingEvent): event is ReplayFrameEvent {
+  return event.type === EventType.Custom;
+}
+
 /**
  * Add an event to the event buffer.
  * `isCheckout` is true if this is either the very first event, or an event triggered by `checkoutEveryNms`.
@@ -42,7 +46,7 @@ export async function addEvent(
     const replayOptions = replay.getOptions();
 
     const eventAfterPossibleCallback =
-      typeof replayOptions.beforeAddRecordingEvent === 'function' && event.type === EventType.Custom
+      typeof replayOptions.beforeAddRecordingEvent === 'function' && isCustomEvent(event)
         ? replayOptions.beforeAddRecordingEvent(event)
         : event;
 
diff --git a/packages/replay/src/util/createBreadcrumb.ts b/packages/replay/src/util/createBreadcrumb.ts
index b8ff6097d571..5cf044333876 100644
--- a/packages/replay/src/util/createBreadcrumb.ts
+++ b/packages/replay/src/util/createBreadcrumb.ts
@@ -1,13 +1,11 @@
-import type { Breadcrumb } from '@sentry/types';
-
-type RequiredProperties = 'category' | 'message';
+import type { BreadcrumbFrame } from '../types/replayFrame';
 
 /**
  * Create a breadcrumb for a replay.
  */
 export function createBreadcrumb(
-  breadcrumb: Pick<Breadcrumb, RequiredProperties> & Partial<Omit<Breadcrumb, RequiredProperties>>,
-): Breadcrumb {
+  breadcrumb: Omit<BreadcrumbFrame, 'timestamp' | 'type'> & Partial<Pick<BreadcrumbFrame, 'timestamp'>>,
+): BreadcrumbFrame {
   return {
     timestamp: Date.now() / 1000,
     type: 'default',
diff --git a/packages/replay/src/util/handleRecordingEmit.ts b/packages/replay/src/util/handleRecordingEmit.ts
index 3a9dcc211edd..e4d507d33456 100644
--- a/packages/replay/src/util/handleRecordingEmit.ts
+++ b/packages/replay/src/util/handleRecordingEmit.ts
@@ -1,7 +1,7 @@
 import { logger } from '@sentry/utils';
 
 import { saveSession } from '../session/saveSession';
-import type { AddEventResult, RecordingEvent, ReplayContainer } from '../types';
+import type { AddEventResult, OptionFrameEvent, RecordingEvent, ReplayContainer } from '../types';
 import { EventType } from '../types/rrweb';
 import { addEvent } from './addEvent';
 
@@ -121,7 +121,7 @@ export function getHandleRecordingEmit(replay: ReplayContainer): RecordingEmitCa
 /**
  * Exported for tests
  */
-export function createOptionsEvent(replay: ReplayContainer): RecordingEvent {
+export function createOptionsEvent(replay: ReplayContainer): OptionFrameEvent {
   const options = replay.getOptions();
   return {
     type: EventType.Custom,
diff --git a/packages/replay/test/integration/beforeAddRecordingEvent.test.ts b/packages/replay/test/integration/beforeAddRecordingEvent.test.ts
index c01140045389..0f9db6554ec9 100644
--- a/packages/replay/test/integration/beforeAddRecordingEvent.test.ts
+++ b/packages/replay/test/integration/beforeAddRecordingEvent.test.ts
@@ -37,7 +37,7 @@ describe('Integration | beforeAddRecordingEvent', () => {
     ({ replay, integration } = await mockSdk({
       replayOptions: {
         beforeAddRecordingEvent: event => {
-          const eventData = event.data as Record<string, any>;
+          const eventData = event.data;
 
           if (eventData.tag === 'breadcrumb' && eventData.payload.category === 'ui.click') {
             return {
diff --git a/packages/replay/test/integration/coreHandlers/handleScope.test.ts b/packages/replay/test/integration/coreHandlers/handleScope.test.ts
index ec17d430ff52..d9d30d710a6a 100644
--- a/packages/replay/test/integration/coreHandlers/handleScope.test.ts
+++ b/packages/replay/test/integration/coreHandlers/handleScope.test.ts
@@ -23,10 +23,10 @@ describe('Integration | coreHandlers | handleScope', () => {
 
     expect(mockHandleScopeListener).toHaveBeenCalledTimes(1);
 
-    getCurrentHub().getScope()?.addBreadcrumb({ message: 'testing' });
+    getCurrentHub().getScope()?.addBreadcrumb({ category: 'console', message: 'testing' });
 
     expect(mockHandleScope).toHaveBeenCalledTimes(1);
-    expect(mockHandleScope).toHaveReturnedWith(expect.objectContaining({ message: 'testing' }));
+    expect(mockHandleScope).toHaveReturnedWith(expect.objectContaining({ category: 'console', message: 'testing' }));
 
     mockHandleScope.mockClear();
 
diff --git a/packages/replay/test/unit/coreHandlers/handleScope.test.ts b/packages/replay/test/unit/coreHandlers/handleScope.test.ts
index 1bce28f860c8..9ce56b89d1e0 100644
--- a/packages/replay/test/unit/coreHandlers/handleScope.test.ts
+++ b/packages/replay/test/unit/coreHandlers/handleScope.test.ts
@@ -63,21 +63,21 @@ describe('Unit | coreHandlers | handleScope', () => {
 
   describe('normalizeConsoleBreadcrumb', () => {
     it('handles console messages with no arguments', () => {
-      const breadcrumb: Breadcrumb = { category: 'console', message: 'test' };
+      const breadcrumb = { category: 'console', message: 'test' };
       const actual = HandleScope.normalizeConsoleBreadcrumb(breadcrumb);
 
       expect(actual).toMatchObject({ category: 'console', message: 'test' });
     });
 
     it('handles console messages with empty arguments', () => {
-      const breadcrumb: Breadcrumb = { category: 'console', message: 'test', data: { arguments: [] } };
+      const breadcrumb = { category: 'console', message: 'test', data: { arguments: [] } };
       const actual = HandleScope.normalizeConsoleBreadcrumb(breadcrumb);
 
       expect(actual).toMatchObject({ category: 'console', message: 'test', data: { arguments: [] } });
     });
 
     it('handles console messages with simple arguments', () => {
-      const breadcrumb: Breadcrumb = {
+      const breadcrumb = {
         category: 'console',
         message: 'test',
         data: { arguments: [1, 'a', true, null, undefined] },
@@ -94,7 +94,7 @@ describe('Unit | coreHandlers | handleScope', () => {
     });
 
     it('truncates large strings', () => {
-      const breadcrumb: Breadcrumb = {
+      const breadcrumb = {
         category: 'console',
         message: 'test',
         data: {
@@ -114,7 +114,7 @@ describe('Unit | coreHandlers | handleScope', () => {
     });
 
     it('truncates large JSON objects', () => {
-      const breadcrumb: Breadcrumb = {
+      const breadcrumb = {
         category: 'console',
         message: 'test',
         data: {
diff --git a/packages/replay/test/unit/util/handleRecordingEmit.test.ts b/packages/replay/test/unit/util/handleRecordingEmit.test.ts
index a4c7f82c425d..7978939291bd 100644
--- a/packages/replay/test/unit/util/handleRecordingEmit.test.ts
+++ b/packages/replay/test/unit/util/handleRecordingEmit.test.ts
@@ -1,7 +1,7 @@
 import { EventType } from '@sentry-internal/rrweb';
 
 import { BASE_TIMESTAMP } from '../..';
-import type { RecordingEvent } from '../../../src/types';
+import type { OptionFrameEvent } from '../../../src/types';
 import * as SentryAddEvent from '../../../src/util/addEvent';
 import { createOptionsEvent, getHandleRecordingEmit } from '../../../src/util/handleRecordingEmit';
 import { setupReplayContainer } from '../../utils/setupReplayContainer';
@@ -9,7 +9,7 @@ import { useFakeTimers } from '../../utils/use-fake-timers';
 
 useFakeTimers();
 
-let optionsEvent: RecordingEvent;
+let optionsEvent: OptionFrameEvent;
 
 describe('Unit | util | handleRecordingEmit', () => {
   let addEventMock: jest.SpyInstance;