diff --git a/packages/browser/src/exports.ts b/packages/browser/src/exports.ts
index 0777d8124579..4a1dc5837747 100644
--- a/packages/browser/src/exports.ts
+++ b/packages/browser/src/exports.ts
@@ -5,9 +5,7 @@ export type {
   SdkInfo,
   Event,
   EventHint,
-  EventStatus,
   Exception,
-  Response,
   // eslint-disable-next-line deprecation/deprecation
   Severity,
   SeverityLevel,
diff --git a/packages/browser/src/transports/xhr.ts b/packages/browser/src/transports/xhr.ts
index 4b36e348de73..0e1e53f91a77 100644
--- a/packages/browser/src/transports/xhr.ts
+++ b/packages/browser/src/transports/xhr.ts
@@ -21,19 +21,18 @@ export interface XHRTransportOptions extends BaseTransportOptions {
  */
 export function makeXHRTransport(options: XHRTransportOptions): Transport {
   function makeRequest(request: TransportRequest): PromiseLike<TransportMakeRequestResponse> {
-    return new SyncPromise<TransportMakeRequestResponse>((resolve, _reject) => {
+    return new SyncPromise((resolve, reject) => {
       const xhr = new XMLHttpRequest();
 
+      xhr.onerror = reject;
+
       xhr.onreadystatechange = (): void => {
         if (xhr.readyState === XHR_READYSTATE_DONE) {
           const response = {
-            body: xhr.response,
             headers: {
               'x-sentry-rate-limits': xhr.getResponseHeader('X-Sentry-Rate-Limits'),
               'retry-after': xhr.getResponseHeader('Retry-After'),
             },
-            reason: xhr.statusText,
-            statusCode: xhr.status,
           };
           resolve(response);
         }
diff --git a/packages/core/src/baseclient.ts b/packages/core/src/baseclient.ts
index 1969f2d8ef0a..2f9508d86603 100644
--- a/packages/core/src/baseclient.ts
+++ b/packages/core/src/baseclient.ts
@@ -3,9 +3,11 @@ import { Scope, Session } from '@sentry/hub';
 import {
   Client,
   ClientOptions,
+  DataCategory,
   DsnComponents,
   Envelope,
   Event,
+  EventDropReason,
   EventHint,
   Integration,
   IntegrationClass,
@@ -87,6 +89,8 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
   /** Number of calls being processed */
   protected _numProcessing: number = 0;
 
+  protected _outcomes: { [key: string]: number } = {};
+
   /**
    * Initializes this client instance.
    *
@@ -97,7 +101,11 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
     if (options.dsn) {
       this._dsn = makeDsn(options.dsn);
       const url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, options.tunnel);
-      this._transport = options.transport({ ...options.transportOptions, url });
+      this._transport = options.transport({
+        ...options.transportOptions,
+        url,
+        recordDroppedEvent: this._recordDroppedEvent.bind(this),
+      });
     } else {
       IS_DEBUG_BUILD && logger.warn('No DSN provided, client will not do anything.');
     }
@@ -266,7 +274,7 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
   public sendEvent(event: Event): void {
     if (this._dsn) {
       const env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);
-      this.sendEnvelope(env);
+      this._sendEnvelope(env);
     }
   }
 
@@ -276,20 +284,7 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
   public sendSession(session: Session | SessionAggregates): void {
     if (this._dsn) {
       const env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);
-      this.sendEnvelope(env);
-    }
-  }
-
-  /**
-   * @inheritdoc
-   */
-  public sendEnvelope(env: Envelope): void {
-    if (this._transport && this._dsn) {
-      this._transport.send(env).then(null, reason => {
-        IS_DEBUG_BUILD && logger.error('Error while sending event:', reason);
-      });
-    } else {
-      IS_DEBUG_BUILD && logger.error('Transport disabled');
+      this._sendEnvelope(env);
     }
   }
 
@@ -564,17 +559,6 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
     // eslint-disable-next-line @typescript-eslint/unbound-method
     const { beforeSend, sampleRate } = this.getOptions();
 
-    // type RecordLostEvent = NonNullable<Transport['recordLostEvent']>;
-    type RecordLostEventParams = unknown[]; // Parameters<RecordLostEvent>;
-
-    // no-op as new transports don't have client outcomes
-    // TODO(v7): Re-add this functionality
-    function recordLostEvent(_outcome: RecordLostEventParams[0], _category: RecordLostEventParams[1]): void {
-      // if (transport.recordLostEvent) {
-      //   transport.recordLostEvent(outcome, category);
-      // }
-    }
-
     if (!this._isEnabled()) {
       return rejectedSyncPromise(new SentryError('SDK not enabled, will not capture event.'));
     }
@@ -584,7 +568,7 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
     // 0.0 === 0% events are sent
     // Sampling for transaction happens somewhere else
     if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {
-      recordLostEvent('sample_rate', 'event');
+      this._recordDroppedEvent('sample_rate', 'error');
       return rejectedSyncPromise(
         new SentryError(
           `Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`,
@@ -595,7 +579,7 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
     return this._prepareEvent(event, scope, hint)
       .then(prepared => {
         if (prepared === null) {
-          recordLostEvent('event_processor', event.type || 'event');
+          this._recordDroppedEvent('event_processor', event.type || 'error');
           throw new SentryError('An event processor returned null, will not send event.');
         }
 
@@ -609,7 +593,7 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
       })
       .then(processedEvent => {
         if (processedEvent === null) {
-          recordLostEvent('before_send', event.type || 'event');
+          this._recordDroppedEvent('before_send', event.type || 'error');
           throw new SentryError('`beforeSend` returned `null`, will not send event.');
         }
 
@@ -655,6 +639,66 @@ export abstract class BaseClient<O extends ClientOptions> implements Client<O> {
     );
   }
 
+  /**
+   * Send outcomes as an envelope
+   */
+  // protected _flushOutcomes(): void {
+  //   if (!this._options.sendClientReports) {
+  //     return;
+  //   }
+  //   const outcomes = this._outcomes;
+  //   this._outcomes = {};
+  //   // Nothing to send
+  //   if (!Object.keys(outcomes).length) {
+  //     IS_DEBUG_BUILD && logger.log('No outcomes to flush');
+  //     return;
+  //   }
+  //   IS_DEBUG_BUILD && logger.log(`Flushing outcomes:\n${JSON.stringify(outcomes, null, 2)}`);
+  //   const url = getEnvelopeEndpointWithUrlEncodedAuth(this._api.dsn, this._api.tunnel);
+  //   const discardedEvents = Object.keys(outcomes).map(key => {
+  //     const [category, reason] = key.split(':');
+  //     return {
+  //       reason,
+  //       category,
+  //       quantity: outcomes[key],
+  //     };
+  //     // TODO: Improve types on discarded_events to get rid of cast
+  //   }) as ClientReport['discarded_events'];
+  //   const envelope = createClientReportEnvelope(discardedEvents, this._api.tunnel && dsnToString(this._api.dsn));
+  //   try {
+  //     sendReport(url, serializeEnvelope(envelope));
+  //   } catch (e) {
+  //     IS_DEBUG_BUILD && logger.error(e);
+  //   }
+  // }
+
+  /**
+   * TODO: Doc
+   */
+  private _recordDroppedEvent(reason: EventDropReason, category: DataCategory): void {
+    // We want to track each category (error, transaction, session) separately
+    // but still keep the distinction between different type of outcomes.
+    // We could use nested maps, but it's much easier to read and type this way.
+    // A correct type for map-based implementation if we want to go that route
+    // would be `Partial<Record<SentryRequestType, Partial<Record<Outcome, number>>>>`
+    const key = `${category}:${reason}`;
+    IS_DEBUG_BUILD && logger.log(`Adding outcome: ${key}`);
+    this._outcomes[key] = this._outcomes[key] + 1 || 1; // This works because undefined + 1 === NaN
+  }
+
+  /**
+   * @inheritdoc
+   */
+  private _sendEnvelope(envelope: Envelope): void {
+    if (this._transport && this._dsn) {
+      this._transport.send(envelope).then(null, reason => {
+        IS_DEBUG_BUILD && logger.error('Error while sending event:', reason);
+      });
+    } else {
+      IS_DEBUG_BUILD && logger.error('Transport disabled');
+    }
+  }
+
   /**
    * @inheritDoc
    */
diff --git a/packages/core/src/envelope.ts b/packages/core/src/envelope.ts
index 53572c844a3e..2f69884e8bc3 100644
--- a/packages/core/src/envelope.ts
+++ b/packages/core/src/envelope.ts
@@ -5,7 +5,6 @@ import {
   EventItem,
   SdkInfo,
   SdkMetadata,
-  SentryRequestType,
   Session,
   SessionAggregates,
   SessionEnvelope,
@@ -52,14 +51,10 @@ export function createSessionEnvelope(
     ...(!!tunnel && { dsn: dsnToString(dsn) }),
   };
 
-  // I know this is hacky but we don't want to add `sessions` to request type since it's never rate limited
-  const type = 'aggregates' in session ? ('sessions' as SentryRequestType) : 'session';
+  const envelopeItem: SessionItem =
+    'aggregates' in session ? [{ type: 'sessions' }, session] : [{ type: 'session' }, session];
 
-  // TODO (v7) Have to cast type because envelope items do not accept a `SentryRequestType`
-  const envelopeItem = [{ type } as { type: 'session' | 'sessions' }, session] as SessionItem;
-  const envelope = createEnvelope<SessionEnvelope>(envelopeHeaders, [envelopeItem]);
-
-  return envelope;
+  return createEnvelope<SessionEnvelope>(envelopeHeaders, [envelopeItem]);
 }
 
 /**
diff --git a/packages/core/src/transports/base.ts b/packages/core/src/transports/base.ts
index 97389ea9a45a..99b38584878a 100644
--- a/packages/core/src/transports/base.ts
+++ b/packages/core/src/transports/base.ts
@@ -1,26 +1,26 @@
 import {
   Envelope,
+  EventDropReason,
   InternalBaseTransportOptions,
   Transport,
-  TransportCategory,
   TransportRequest,
   TransportRequestExecutor,
-  TransportResponse,
 } from '@sentry/types';
 import {
-  disabledUntil,
-  eventStatusFromHttpCode,
-  getEnvelopeType,
+  envelopeItemTypeToDataCategory,
   isRateLimited,
+  logger,
   makePromiseBuffer,
   PromiseBuffer,
   RateLimits,
-  rejectedSyncPromise,
   resolvedSyncPromise,
+  SentryError,
   serializeEnvelope,
   updateRateLimits,
 } from '@sentry/utils';
 
+import { IS_DEBUG_BUILD } from '../flags';
+
 export const DEFAULT_TRANSPORT_BUFFER_SIZE = 30;
 
 /**
@@ -32,47 +32,72 @@ export const DEFAULT_TRANSPORT_BUFFER_SIZE = 30;
 export function createTransport(
   options: InternalBaseTransportOptions,
   makeRequest: TransportRequestExecutor,
-  buffer: PromiseBuffer<TransportResponse> = makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE),
+  buffer: PromiseBuffer<void> = makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE),
 ): Transport {
   let rateLimits: RateLimits = {};
 
   const flush = (timeout?: number): PromiseLike<boolean> => buffer.drain(timeout);
 
-  function send(envelope: Envelope): PromiseLike<TransportResponse> {
-    const envCategory = getEnvelopeType(envelope);
-    const category = envCategory === 'event' ? 'error' : (envCategory as TransportCategory);
-    const request: TransportRequest = {
-      category,
-      body: serializeEnvelope(envelope),
-    };
+  function send(envelope: Envelope): PromiseLike<void> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const filteredEnvelopeItems = (envelope[1] as any[]).filter((envelopeItem: Envelope[1][number]) => {
+      const envelopeItemType = envelopeItem[0].type;
 
-    // Don't add to buffer if transport is already rate-limited
-    if (isRateLimited(rateLimits, category)) {
-      return rejectedSyncPromise({
-        status: 'rate_limit',
-        reason: getRateLimitReason(rateLimits, category),
-      });
+      const itemIsRateLimited = isRateLimited(rateLimits, envelopeItemType);
+
+      if (itemIsRateLimited && options.recordDroppedEvent) {
+        options.recordDroppedEvent('ratelimit_backoff', envelopeItemTypeToDataCategory(envelopeItemType));
+      }
+
+      return !itemIsRateLimited;
+    });
+
+    if (filteredEnvelopeItems.length === 0) {
+      return resolvedSyncPromise(undefined);
     }
 
-    const requestTask = (): PromiseLike<TransportResponse> =>
-      makeRequest(request).then(({ body, headers, reason, statusCode }): PromiseLike<TransportResponse> => {
-        const status = eventStatusFromHttpCode(statusCode);
-        if (headers) {
-          rateLimits = updateRateLimits(rateLimits, headers);
-        }
-        if (status === 'success') {
-          return resolvedSyncPromise({ status, reason });
+    const filteredEvelope: Envelope = [envelope[0], filteredEnvelopeItems];
+
+    const recordEnvelopeLoss = (reason: EventDropReason): void => {
+      envelope[1].forEach((envelopeItem: Envelope[1][number]) => {
+        const envelopeItemType = envelopeItem[0].type;
+        if (options.recordDroppedEvent) {
+          options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(envelopeItemType));
         }
-        return rejectedSyncPromise({
-          status,
-          reason:
-            reason ||
-            body ||
-            (status === 'rate_limit' ? getRateLimitReason(rateLimits, category) : 'Unknown transport error'),
-        });
       });
+    };
+
+    const request: TransportRequest = {
+      body: serializeEnvelope(filteredEvelope),
+    };
+
+    const requestTask = (): PromiseLike<void> =>
+      makeRequest(request).then(
+        ({ headers }): PromiseLike<void> => {
+          if (headers) {
+            rateLimits = updateRateLimits(rateLimits, headers);
+          }
 
-    return buffer.add(requestTask);
+          return resolvedSyncPromise(undefined);
+        },
+        error => {
+          IS_DEBUG_BUILD && logger.error('Failed while making request:', error);
+          recordEnvelopeLoss('network_error');
+          return resolvedSyncPromise(undefined);
+        },
+      );
+
+    return buffer.add(requestTask).then(
+      result => result,
+      error => {
+        if (error instanceof SentryError) {
+          recordEnvelopeLoss('queue_overflow');
+          return resolvedSyncPromise(undefined);
+        } else {
+          throw error;
+        }
+      },
+    );
   }
 
   return {
@@ -80,9 +105,3 @@ export function createTransport(
     flush,
   };
 }
-
-function getRateLimitReason(rateLimits: RateLimits, category: TransportCategory): string {
-  return `Too many ${category} requests, backing off until: ${new Date(
-    disabledUntil(rateLimits, category),
-  ).toISOString()}`;
-}
diff --git a/packages/node/src/index.ts b/packages/node/src/index.ts
index ec659b543bff..c84836251510 100644
--- a/packages/node/src/index.ts
+++ b/packages/node/src/index.ts
@@ -5,9 +5,7 @@ export type {
   SdkInfo,
   Event,
   EventHint,
-  EventStatus,
   Exception,
-  Response,
   // eslint-disable-next-line deprecation/deprecation
   Severity,
   SeverityLevel,
diff --git a/packages/node/src/transports/http.ts b/packages/node/src/transports/http.ts
index 0352a8232e04..1ba591c54379 100644
--- a/packages/node/src/transports/http.ts
+++ b/packages/node/src/transports/http.ts
@@ -6,7 +6,6 @@ import {
   TransportRequest,
   TransportRequestExecutor,
 } from '@sentry/types';
-import { eventStatusFromHttpCode } from '@sentry/utils';
 import * as http from 'http';
 import * as https from 'https';
 import { URL } from 'url';
@@ -106,9 +105,6 @@ function createRequestExecutor(
             // Drain socket
           });
 
-          const statusCode = res.statusCode ?? 500;
-          const status = eventStatusFromHttpCode(statusCode);
-
           res.setEncoding('utf8');
 
           // "Key-value pairs of header names and values. Header names are lower-cased."
@@ -121,8 +117,6 @@ function createRequestExecutor(
               'retry-after': retryAfterHeader,
               'x-sentry-rate-limits': Array.isArray(rateLimitsHeader) ? rateLimitsHeader[0] : rateLimitsHeader,
             },
-            reason: status,
-            statusCode: statusCode,
           });
         },
       );
diff --git a/packages/tracing/src/index.bundle.ts b/packages/tracing/src/index.bundle.ts
index 56e35e0ceaaa..130270af8851 100644
--- a/packages/tracing/src/index.bundle.ts
+++ b/packages/tracing/src/index.bundle.ts
@@ -3,9 +3,7 @@ export type {
   Request,
   SdkInfo,
   Event,
-  EventStatus,
   Exception,
-  Response,
   // eslint-disable-next-line deprecation/deprecation
   Severity,
   SeverityLevel,
diff --git a/packages/types/src/clientreport.ts b/packages/types/src/clientreport.ts
index 22c590d0cc64..b873f0308f9d 100644
--- a/packages/types/src/clientreport.ts
+++ b/packages/types/src/clientreport.ts
@@ -1,7 +1,20 @@
-import { SentryRequestType } from './request';
-import { Outcome } from './transport';
+import { DataCategory } from './transport';
+
+export type EventDropReason =
+  | 'before_send'
+  | 'event_processor'
+  | 'network_error'
+  | 'queue_overflow'
+  | 'ratelimit_backoff'
+  | 'sample_rate';
+
+export interface Outcome {
+  reason: EventDropReason;
+  category: DataCategory;
+  quantity: number;
+}
 
 export type ClientReport = {
   timestamp: number;
-  discarded_events: Array<{ reason: Outcome; category: SentryRequestType; quantity: number }>;
+  discarded_events: Outcome[];
 };
diff --git a/packages/types/src/envelope.ts b/packages/types/src/envelope.ts
index 8e5091dbbfa9..537f766cfbdc 100644
--- a/packages/types/src/envelope.ts
+++ b/packages/types/src/envelope.ts
@@ -21,6 +21,16 @@ export type BaseEnvelopeItemHeaders = {
 
 type BaseEnvelopeItem<IH extends BaseEnvelopeItemHeaders, P extends unknown> = [IH, P]; // P is for payload
 
+// TEMP Comment: We could also infer this type
+export type EnvelopeItemType =
+  | 'client_report'
+  | 'user_report'
+  | 'session'
+  | 'sessions'
+  | 'transaction'
+  | 'attachment'
+  | 'event';
+
 type BaseEnvelope<EH extends BaseEnvelopeHeaders, I extends BaseEnvelopeItem<BaseEnvelopeItemHeaders, unknown>> = [
   EH,
   I[],
diff --git a/packages/types/src/eventstatus.ts b/packages/types/src/eventstatus.ts
deleted file mode 100644
index 498f0f45b3dd..000000000000
--- a/packages/types/src/eventstatus.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-export type EventStatus =
-  /** The status could not be determined. */
-  | 'unknown'
-  /** The event was skipped due to configuration or callbacks. */
-  | 'skipped'
-  /** The event was sent to Sentry successfully. */
-  | 'rate_limit'
-  /** The client is currently rate limited and will try again later. */
-  | 'invalid'
-  /** The event could not be processed. */
-  | 'failed'
-  /** A server-side error occurred during submission. */
-  | 'success';
diff --git a/packages/types/src/index.ts b/packages/types/src/index.ts
index ab2592cfe02e..dbf1ee6cfbfb 100644
--- a/packages/types/src/index.ts
+++ b/packages/types/src/index.ts
@@ -1,6 +1,6 @@
 export type { Breadcrumb, BreadcrumbHint } from './breadcrumb';
 export type { Client } from './client';
-export type { ClientReport } from './clientreport';
+export type { Outcome, ClientReport, EventDropReason } from './clientreport';
 export type { Context, Contexts } from './context';
 export type { DsnComponents, DsnLike, DsnProtocol } from './dsn';
 export type { DebugImage, DebugImageType, DebugMeta } from './debugMeta';
@@ -11,6 +11,7 @@ export type {
   ClientReportEnvelope,
   ClientReportItem,
   Envelope,
+  EnvelopeItemType,
   EventEnvelope,
   EventItem,
   SessionEnvelope,
@@ -19,7 +20,6 @@ export type {
 } from './envelope';
 export type { ExtendedError } from './error';
 export type { Event, EventHint } from './event';
-export type { EventStatus } from './eventstatus';
 export type { EventProcessor } from './eventprocessor';
 export type { Exception } from './exception';
 export type { Extra, Extras } from './extra';
@@ -29,8 +29,7 @@ export type { Mechanism } from './mechanism';
 export type { ExtractedNodeRequestData, Primitive, WorkerLocation } from './misc';
 export type { ClientOptions, Options } from './options';
 export type { Package } from './package';
-export type { QueryParams, Request, SentryRequest, SentryRequestType } from './request';
-export type { Response } from './response';
+export type { QueryParams, Request } from './request';
 export type { Runtime } from './runtime';
 export type { CaptureContext, Scope, ScopeContext } from './scope';
 export type { SdkInfo } from './sdkinfo';
@@ -63,12 +62,10 @@ export type {
 } from './transaction';
 export type { Thread } from './thread';
 export type {
-  Outcome,
   Transport,
-  TransportCategory,
+  DataCategory,
   TransportRequest,
   TransportMakeRequestResponse,
-  TransportResponse,
   InternalBaseTransportOptions,
   BaseTransportOptions,
   TransportRequestExecutor,
diff --git a/packages/types/src/request.ts b/packages/types/src/request.ts
index 052de1b41c08..c06b29525a84 100644
--- a/packages/types/src/request.ts
+++ b/packages/types/src/request.ts
@@ -1,14 +1,3 @@
-/** Possible SentryRequest types that can be used to make a distinction between Sentry features */
-// NOTE(kamil): It would be nice if we make it a valid enum instead
-export type SentryRequestType = 'event' | 'transaction' | 'session' | 'attachment';
-
-/** A generic client request. */
-export interface SentryRequest {
-  body: string;
-  type: SentryRequestType;
-  url: string;
-}
-
 /** Request data included in an event as sent to Sentry */
 export interface Request {
   url?: string;
diff --git a/packages/types/src/response.ts b/packages/types/src/response.ts
deleted file mode 100644
index 4add517f4870..000000000000
--- a/packages/types/src/response.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-import { Event, EventType } from './event';
-import { EventStatus } from './eventstatus';
-import { Session } from './session';
-
-/** JSDoc */
-export interface Response {
-  status: EventStatus;
-  event?: Event | Session;
-  type?: EventType;
-  reason?: string;
-}
diff --git a/packages/types/src/transport.ts b/packages/types/src/transport.ts
index 1c2449a386b5..3ae7d0608ee2 100644
--- a/packages/types/src/transport.ts
+++ b/packages/types/src/transport.ts
@@ -1,40 +1,26 @@
+import { EventDropReason } from './clientreport';
 import { Envelope } from './envelope';
-import { EventStatus } from './eventstatus';
 
-export type Outcome =
-  | 'before_send'
-  | 'event_processor'
-  | 'network_error'
-  | 'queue_overflow'
-  | 'ratelimit_backoff'
-  | 'sample_rate';
-
-export type TransportCategory = 'error' | 'transaction' | 'attachment' | 'session';
+// Used in various places like Client Reports and Rate Limit Categories
+export type DataCategory = 'default' | 'transaction' | 'error' | 'security' | 'attachment' | 'session' | 'internal';
 
 export type TransportRequest = {
   body: string;
-  category: TransportCategory;
 };
 
 export type TransportMakeRequestResponse = {
-  body?: string;
   headers?: {
     [key: string]: string | null;
     'x-sentry-rate-limits': string | null;
     'retry-after': string | null;
   };
-  reason?: string;
-  statusCode: number;
-};
-
-export type TransportResponse = {
-  status: EventStatus;
-  reason?: string;
 };
 
 export interface InternalBaseTransportOptions {
   bufferSize?: number;
+  recordDroppedEvent?: (reason: EventDropReason, dataCategory: DataCategory) => void;
 }
+
 export interface BaseTransportOptions extends InternalBaseTransportOptions {
   // url to send the event
   // transport does not care about dsn specific - client should take care of
@@ -43,8 +29,12 @@ export interface BaseTransportOptions extends InternalBaseTransportOptions {
 }
 
 export interface Transport {
-  send(request: Envelope): PromiseLike<TransportResponse>;
+  send(request: Envelope): PromiseLike<void>;
   flush(timeout?: number): PromiseLike<boolean>;
 }
 
+/**
+ * Executes a transport request.
+ * This function should return a rejected promise when an error occurs during transmission (ie, a network error).
+ */
 export type TransportRequestExecutor = (request: TransportRequest) => PromiseLike<TransportMakeRequestResponse>;
diff --git a/packages/utils/src/envelope.ts b/packages/utils/src/envelope.ts
index 0000e6007aee..b4573428f1c1 100644
--- a/packages/utils/src/envelope.ts
+++ b/packages/utils/src/envelope.ts
@@ -1,4 +1,4 @@
-import { Envelope } from '@sentry/types';
+import { DataCategory, Envelope, EnvelopeItemType } from '@sentry/types';
 
 import { isPrimitive } from './is';
 
@@ -48,3 +48,19 @@ export function serializeEnvelope(envelope: Envelope): string {
     return `${acc}\n${JSON.stringify(itemHeaders)}\n${serializedPayload}`;
   }, serializedHeaders);
 }
+
+/**
+ * TODO: Docs
+ */
+export function envelopeItemTypeToDataCategory(type: EnvelopeItemType): DataCategory {
+  const map = {
+    session: 'session',
+    sessions: 'session',
+    attachment: 'attachment',
+    transaction: 'transaction',
+    event: 'error',
+    client_report: 'internal',
+    user_report: 'default',
+  } as const;
+  return map[type];
+}
diff --git a/packages/utils/src/index.ts b/packages/utils/src/index.ts
index 0f004218c052..01b875dc31c3 100644
--- a/packages/utils/src/index.ts
+++ b/packages/utils/src/index.ts
@@ -14,7 +14,6 @@ export * from './path';
 export * from './promisebuffer';
 export * from './severity';
 export * from './stacktrace';
-export * from './status';
 export * from './string';
 export * from './supports';
 export * from './syncpromise';
diff --git a/packages/utils/src/ratelimit.ts b/packages/utils/src/ratelimit.ts
index 59906c0abdaf..c9c860a59739 100644
--- a/packages/utils/src/ratelimit.ts
+++ b/packages/utils/src/ratelimit.ts
@@ -1,4 +1,4 @@
-// Keeping the key broad until we add the new transports
+// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned
 export type RateLimits = Record<string, number>;
 
 export const DEFAULT_RETRY_AFTER = 60 * 1000; // 60 seconds
diff --git a/packages/utils/src/status.ts b/packages/utils/src/status.ts
deleted file mode 100644
index 381a0971b66f..000000000000
--- a/packages/utils/src/status.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { EventStatus } from '@sentry/types';
-/**
- * Converts an HTTP status code to sentry status {@link EventStatus}.
- *
- * @param code number HTTP status code
- * @returns EventStatus
- */
-export function eventStatusFromHttpCode(code: number): EventStatus {
-  if (code >= 200 && code < 300) {
-    return 'success';
-  }
-
-  if (code === 429) {
-    return 'rate_limit';
-  }
-
-  if (code >= 400 && code < 500) {
-    return 'invalid';
-  }
-
-  if (code >= 500) {
-    return 'failed';
-  }
-
-  return 'unknown';
-}
diff --git a/packages/vue/src/index.bundle.ts b/packages/vue/src/index.bundle.ts
index c2b744280372..f28600b793a6 100644
--- a/packages/vue/src/index.bundle.ts
+++ b/packages/vue/src/index.bundle.ts
@@ -3,9 +3,7 @@ export type {
   Request,
   SdkInfo,
   Event,
-  EventStatus,
   Exception,
-  Response,
   SeverityLevel,
   StackFrame,
   Stacktrace,