FRE-709: Document duplicate recovery wake - FRE-635 already recovered via FRE-708

node_modules/svix/src/models/adobeSignConfig.ts

@@ -0,0 +1,19 @@
+// this file is @generated
+
+export interface AdobeSignConfig {
+  clientId: string;
+}
+
+export const AdobeSignConfigSerializer = {
+  _fromJsonObject(object: any): AdobeSignConfig {
+    return {
+      clientId: object["clientId"],
+    };
+  },
+
+  _toJsonObject(self: AdobeSignConfig): any {
+    return {
+      clientId: self.clientId,
+    };
+  },
+};

node_modules/svix/src/models/adobeSignConfigOut.ts

@@ -0,0 +1,15 @@
+// this file is @generated
+
+// biome-ignore-all lint/suspicious/noEmptyInterface: backwards compat
+
+export interface AdobeSignConfigOut {}
+
+export const AdobeSignConfigOutSerializer = {
+  _fromJsonObject(_object: any): AdobeSignConfigOut {
+    return {};
+  },
+
+  _toJsonObject(_self: AdobeSignConfigOut): any {
+    return {};
+  },
+};

node_modules/svix/src/models/aggregateEventTypesOut.ts

@@ -0,0 +1,37 @@
+// this file is @generated
+import {
+  type BackgroundTaskStatus,
+  BackgroundTaskStatusSerializer,
+} from "./backgroundTaskStatus";
+import {
+  type BackgroundTaskType,
+  BackgroundTaskTypeSerializer,
+} from "./backgroundTaskType";
+
+export interface AggregateEventTypesOut {
+  /** The QueueBackgroundTask's ID. */
+  id: string;
+  status: BackgroundTaskStatus;
+  task: BackgroundTaskType;
+  updatedAt: Date;
+}
+
+export const AggregateEventTypesOutSerializer = {
+  _fromJsonObject(object: any): AggregateEventTypesOut {
+    return {
+      id: object["id"],
+      status: BackgroundTaskStatusSerializer._fromJsonObject(object["status"]),
+      task: BackgroundTaskTypeSerializer._fromJsonObject(object["task"]),
+      updatedAt: new Date(object["updatedAt"]),
+    };
+  },
+
+  _toJsonObject(self: AggregateEventTypesOut): any {
+    return {
+      id: self.id,
+      status: BackgroundTaskStatusSerializer._toJsonObject(self.status),
+      task: BackgroundTaskTypeSerializer._toJsonObject(self.task),
+      updatedAt: self.updatedAt,
+    };
+  },
+};

node_modules/svix/src/models/airwallexConfig.ts

@@ -0,0 +1,19 @@
+// this file is @generated
+
+export interface AirwallexConfig {
+  secret: string;
+}
+
+export const AirwallexConfigSerializer = {
+  _fromJsonObject(object: any): AirwallexConfig {
+    return {
+      secret: object["secret"],
+    };
+  },
+
+  _toJsonObject(self: AirwallexConfig): any {
+    return {
+      secret: self.secret,
+    };
+  },
+};

node_modules/svix/src/models/airwallexConfigOut.ts

@@ -0,0 +1,15 @@
+// this file is @generated
+
+// biome-ignore-all lint/suspicious/noEmptyInterface: backwards compat
+
+export interface AirwallexConfigOut {}
+
+export const AirwallexConfigOutSerializer = {
+  _fromJsonObject(_object: any): AirwallexConfigOut {
+    return {};
+  },
+
+  _toJsonObject(_self: AirwallexConfigOut): any {
+    return {};
+  },
+};

node_modules/svix/src/models/amazonS3PatchConfig.ts

@@ -0,0 +1,31 @@
+// this file is @generated
+
+export interface AmazonS3PatchConfig {
+  accessKeyId?: string;
+  bucket?: string;
+  endpointUrl?: string;
+  region?: string;
+  secretAccessKey?: string;
+}
+
+export const AmazonS3PatchConfigSerializer = {
+  _fromJsonObject(object: any): AmazonS3PatchConfig {
+    return {
+      accessKeyId: object["accessKeyId"],
+      bucket: object["bucket"],
+      endpointUrl: object["endpointUrl"],
+      region: object["region"],
+      secretAccessKey: object["secretAccessKey"],
+    };
+  },
+
+  _toJsonObject(self: AmazonS3PatchConfig): any {
+    return {
+      accessKeyId: self.accessKeyId,
+      bucket: self.bucket,
+      endpointUrl: self.endpointUrl,
+      region: self.region,
+      secretAccessKey: self.secretAccessKey,
+    };
+  },
+};

node_modules/svix/src/models/apiTokenOut.ts

@@ -0,0 +1,34 @@
+// this file is @generated
+
+export interface ApiTokenOut {
+  createdAt: Date;
+  expiresAt?: Date | null;
+  id: string;
+  name?: string | null;
+  scopes?: string[] | null;
+  token: string;
+}
+
+export const ApiTokenOutSerializer = {
+  _fromJsonObject(object: any): ApiTokenOut {
+    return {
+      createdAt: new Date(object["createdAt"]),
+      expiresAt: object["expiresAt"] ? new Date(object["expiresAt"]) : null,
+      id: object["id"],
+      name: object["name"],
+      scopes: object["scopes"],
+      token: object["token"],
+    };
+  },
+
+  _toJsonObject(self: ApiTokenOut): any {
+    return {
+      createdAt: self.createdAt,
+      expiresAt: self.expiresAt,
+      id: self.id,
+      name: self.name,
+      scopes: self.scopes,
+      token: self.token,
+    };
+  },
+};

node_modules/svix/src/models/appPortalAccessIn.ts

@@ -0,0 +1,89 @@
+// this file is @generated
+import {
+  type AppPortalCapability,
+  AppPortalCapabilitySerializer,
+} from "./appPortalCapability";
+import { type ApplicationIn, ApplicationInSerializer } from "./applicationIn";
+
+export interface AppPortalAccessIn {
+  /**
+   * Optionally creates a new application while generating the access link.
+   *
+   * If the application id or uid that is used in the path already exists, this argument is ignored.
+   */
+  application?: ApplicationIn | null;
+  /**
+   * Custom capabilities attached to the token, You can combine as many capabilities as necessary.
+   *
+   * The `ViewBase` capability is always required
+   *
+   * - `ViewBase`: Basic read only permissions, does not allow the user to see the endpoint secret.
+   *
+   * - `ViewEndpointSecret`: Allows user to view the endpoint secret.
+   *
+   * - `ManageEndpointSecret`: Allows user to rotate and view the endpoint secret.
+   *
+   * - `ManageTransformations`: Allows user to modify the endpoint transformations.
+   *
+   * - `CreateAttempts`: Allows user to replay missing messages and send example messages.
+   *
+   * - `ManageEndpoint`: Allows user to read/modify any field or configuration of an endpoint (including secrets)
+   *
+   * By default, the token will get all capabilities if the capabilities are not explicitly specified.
+   */
+  capabilities?: AppPortalCapability[] | null;
+  /**
+   * How long the token will be valid for, in seconds.
+   *
+   * Valid values are between 1 hour and 7 days. The default is 7 days.
+   */
+  expiry?: number | null;
+  /** The set of feature flags the created token will have access to. */
+  featureFlags?: string[];
+  /**
+   * Whether the app portal should be in read-only mode.
+   *
+   * @deprecated
+   */
+  readOnly?: boolean | null;
+  /**
+   * An optional session ID to attach to the token.
+   *
+   * When expiring tokens with "Expire All", you can include the session ID to only expire tokens that were created with that session ID.
+   */
+  sessionId?: string | null;
+}
+
+export const AppPortalAccessInSerializer = {
+  _fromJsonObject(object: any): AppPortalAccessIn {
+    return {
+      application:
+        object["application"] != null
+          ? ApplicationInSerializer._fromJsonObject(object["application"])
+          : undefined,
+      capabilities: object["capabilities"]?.map((item: AppPortalCapability) =>
+        AppPortalCapabilitySerializer._fromJsonObject(item)
+      ),
+      expiry: object["expiry"],
+      featureFlags: object["featureFlags"],
+      readOnly: object["readOnly"],
+      sessionId: object["sessionId"],
+    };
+  },
+
+  _toJsonObject(self: AppPortalAccessIn): any {
+    return {
+      application:
+        self.application != null
+          ? ApplicationInSerializer._toJsonObject(self.application)
+          : undefined,
+      capabilities: self.capabilities?.map((item) =>
+        AppPortalCapabilitySerializer._toJsonObject(item)
+      ),
+      expiry: self.expiry,
+      featureFlags: self.featureFlags,
+      readOnly: self.readOnly,
+      sessionId: self.sessionId,
+    };
+  },
+};

node_modules/svix/src/models/appPortalAccessOut.ts

@@ -0,0 +1,22 @@
+// this file is @generated
+
+export interface AppPortalAccessOut {
+  token: string;
+  url: string;
+}
+
+export const AppPortalAccessOutSerializer = {
+  _fromJsonObject(object: any): AppPortalAccessOut {
+    return {
+      token: object["token"],
+      url: object["url"],
+    };
+  },
+
+  _toJsonObject(self: AppPortalAccessOut): any {
+    return {
+      token: self.token,
+      url: self.url,
+    };
+  },
+};

node_modules/svix/src/models/appPortalCapability.ts

@@ -0,0 +1,20 @@
+// this file is @generated
+
+export enum AppPortalCapability {
+  ViewBase = "ViewBase",
+  ViewEndpointSecret = "ViewEndpointSecret",
+  ManageEndpointSecret = "ManageEndpointSecret",
+  ManageTransformations = "ManageTransformations",
+  CreateAttempts = "CreateAttempts",
+  ManageEndpoint = "ManageEndpoint",
+}
+
+export const AppPortalCapabilitySerializer = {
+  _fromJsonObject(object: any): AppPortalCapability {
+    return object;
+  },
+
+  _toJsonObject(self: AppPortalCapability): any {
+    return self;
+  },
+};

node_modules/svix/src/models/appUsageStatsIn.ts

@@ -0,0 +1,30 @@
+// this file is @generated
+
+export interface AppUsageStatsIn {
+  /**
+   * Specific app IDs or UIDs to aggregate stats for.
+   *
+   * Note that if none of the given IDs or UIDs are resolved, a 422 response will be given.
+   */
+  appIds?: string[] | null;
+  since: Date;
+  until: Date;
+}
+
+export const AppUsageStatsInSerializer = {
+  _fromJsonObject(object: any): AppUsageStatsIn {
+    return {
+      appIds: object["appIds"],
+      since: new Date(object["since"]),
+      until: new Date(object["until"]),
+    };
+  },
+
+  _toJsonObject(self: AppUsageStatsIn): any {
+    return {
+      appIds: self.appIds,
+      since: self.since,
+      until: self.until,
+    };
+  },
+};

node_modules/svix/src/models/appUsageStatsOut.ts

@@ -0,0 +1,45 @@
+// this file is @generated
+import {
+  type BackgroundTaskStatus,
+  BackgroundTaskStatusSerializer,
+} from "./backgroundTaskStatus";
+import {
+  type BackgroundTaskType,
+  BackgroundTaskTypeSerializer,
+} from "./backgroundTaskType";
+
+export interface AppUsageStatsOut {
+  /** The QueueBackgroundTask's ID. */
+  id: string;
+  status: BackgroundTaskStatus;
+  task: BackgroundTaskType;
+  /**
+   * Any app IDs or UIDs received in the request that weren't found.
+   *
+   * Stats will be produced for all the others.
+   */
+  unresolvedAppIds: string[];
+  updatedAt: Date;
+}
+
+export const AppUsageStatsOutSerializer = {
+  _fromJsonObject(object: any): AppUsageStatsOut {
+    return {
+      id: object["id"],
+      status: BackgroundTaskStatusSerializer._fromJsonObject(object["status"]),
+      task: BackgroundTaskTypeSerializer._fromJsonObject(object["task"]),
+      unresolvedAppIds: object["unresolvedAppIds"],
+      updatedAt: new Date(object["updatedAt"]),
+    };
+  },
+
+  _toJsonObject(self: AppUsageStatsOut): any {
+    return {
+      id: self.id,
+      status: BackgroundTaskStatusSerializer._toJsonObject(self.status),
+      task: BackgroundTaskTypeSerializer._toJsonObject(self.task),
+      unresolvedAppIds: self.unresolvedAppIds,
+      updatedAt: self.updatedAt,
+    };
+  },
+};

node_modules/svix/src/models/applicationIn.ts

@@ -0,0 +1,43 @@
+// this file is @generated
+
+export interface ApplicationIn {
+  metadata?: { [key: string]: string };
+  /** Application name for human consumption. */
+  name: string;
+  /**
+   * Deprecated, use `throttleRate` instead.
+   *
+   * @deprecated
+   */
+  rateLimit?: number | null;
+  /**
+   * Maximum messages per second to send to this application.
+   *
+   * Outgoing messages will be throttled to this rate.
+   */
+  throttleRate?: number | null;
+  /** Optional unique identifier for the application. */
+  uid?: string | null;
+}
+
+export const ApplicationInSerializer = {
+  _fromJsonObject(object: any): ApplicationIn {
+    return {
+      metadata: object["metadata"],
+      name: object["name"],
+      rateLimit: object["rateLimit"],
+      throttleRate: object["throttleRate"],
+      uid: object["uid"],
+    };
+  },
+
+  _toJsonObject(self: ApplicationIn): any {
+    return {
+      metadata: self.metadata,
+      name: self.name,
+      rateLimit: self.rateLimit,
+      throttleRate: self.throttleRate,
+      uid: self.uid,
+    };
+  },
+};

node_modules/svix/src/models/applicationOut.ts

@@ -0,0 +1,53 @@
+// this file is @generated
+
+export interface ApplicationOut {
+  createdAt: Date;
+  /** The Application's ID. */
+  id: string;
+  metadata: { [key: string]: string };
+  /** Application name for human consumption. */
+  name: string;
+  /**
+   * Deprecated, use `throttleRate` instead.
+   *
+   * @deprecated
+   */
+  rateLimit?: number | null;
+  /**
+   * Maximum messages per second to send to this application.
+   *
+   * Outgoing messages will be throttled to this rate.
+   */
+  throttleRate?: number | null;
+  /** Optional unique identifier for the application. */
+  uid?: string | null;
+  updatedAt: Date;
+}
+
+export const ApplicationOutSerializer = {
+  _fromJsonObject(object: any): ApplicationOut {
+    return {
+      createdAt: new Date(object["createdAt"]),
+      id: object["id"],
+      metadata: object["metadata"],
+      name: object["name"],
+      rateLimit: object["rateLimit"],
+      throttleRate: object["throttleRate"],
+      uid: object["uid"],
+      updatedAt: new Date(object["updatedAt"]),
+    };
+  },
+
+  _toJsonObject(self: ApplicationOut): any {
+    return {
+      createdAt: self.createdAt,
+      id: self.id,
+      metadata: self.metadata,
+      name: self.name,
+      rateLimit: self.rateLimit,
+      throttleRate: self.throttleRate,
+      uid: self.uid,
+      updatedAt: self.updatedAt,
+    };
+  },
+};

node_modules/svix/src/models/applicationPatch.ts

@@ -0,0 +1,29 @@
+// this file is @generated
+
+export interface ApplicationPatch {
+  metadata?: { [key: string]: string };
+  name?: string;
+  rateLimit?: number | null;
+  /** The Application's UID. */
+  uid?: string | null;
+}
+
+export const ApplicationPatchSerializer = {
+  _fromJsonObject(object: any): ApplicationPatch {
+    return {
+      metadata: object["metadata"],
+      name: object["name"],
+      rateLimit: object["rateLimit"],
+      uid: object["uid"],
+    };
+  },
+
+  _toJsonObject(self: ApplicationPatch): any {
+    return {
+      metadata: self.metadata,
+      name: self.name,
+      rateLimit: self.rateLimit,
+      uid: self.uid,
+    };
+  },
+};

node_modules/svix/src/models/applicationTokenExpireIn.ts

@@ -0,0 +1,28 @@
+// this file is @generated
+
+export interface ApplicationTokenExpireIn {
+  /** How many seconds until the old key is expired. */
+  expiry?: number | null;
+  /**
+   * An optional list of session ids.
+   *
+   * If any session ids are specified, only Application tokens created with that session id will be expired.
+   */
+  sessionIds?: string[];
+}
+
+export const ApplicationTokenExpireInSerializer = {
+  _fromJsonObject(object: any): ApplicationTokenExpireIn {
+    return {
+      expiry: object["expiry"],
+      sessionIds: object["sessionIds"],
+    };
+  },
+
+  _toJsonObject(self: ApplicationTokenExpireIn): any {
+    return {
+      expiry: self.expiry,
+      sessionIds: self.sessionIds,
+    };
+  },
+};

node_modules/svix/src/models/azureBlobStorageConfig.ts

@@ -0,0 +1,25 @@
+// this file is @generated
+
+export interface AzureBlobStorageConfig {
+  accessKey: string;
+  account: string;
+  container: string;
+}
+
+export const AzureBlobStorageConfigSerializer = {
+  _fromJsonObject(object: any): AzureBlobStorageConfig {
+    return {
+      accessKey: object["accessKey"],
+      account: object["account"],
+      container: object["container"],
+    };
+  },
+
+  _toJsonObject(self: AzureBlobStorageConfig): any {
+    return {
+      accessKey: self.accessKey,
+      account: self.account,
+      container: self.container,
+    };
+  },
+};

node_modules/svix/src/models/azureBlobStoragePatchConfig.ts

@@ -0,0 +1,25 @@
+// this file is @generated
+
+export interface AzureBlobStoragePatchConfig {
+  accessKey?: string;
+  account?: string;
+  container?: string;
+}
+
+export const AzureBlobStoragePatchConfigSerializer = {
+  _fromJsonObject(object: any): AzureBlobStoragePatchConfig {
+    return {
+      accessKey: object["accessKey"],
+      account: object["account"],
+      container: object["container"],
+    };
+  },
+
+  _toJsonObject(self: AzureBlobStoragePatchConfig): any {
+    return {
+      accessKey: self.accessKey,
+      account: self.account,
+      container: self.container,
+    };
+  },
+};

node_modules/svix/src/models/backgroundTaskFinishedEvent.ts

@@ -0,0 +1,27 @@
+// this file is @generated
+import {
+  type BackgroundTaskFinishedEvent2,
+  BackgroundTaskFinishedEvent2Serializer,
+} from "./backgroundTaskFinishedEvent2";
+
+/** Sent when a background task is finished. */
+export interface BackgroundTaskFinishedEvent {
+  data: BackgroundTaskFinishedEvent2;
+  type: string;
+}
+
+export const BackgroundTaskFinishedEventSerializer = {
+  _fromJsonObject(object: any): BackgroundTaskFinishedEvent {
+    return {
+      data: BackgroundTaskFinishedEvent2Serializer._fromJsonObject(object["data"]),
+      type: object["type"],
+    };
+  },
+
+  _toJsonObject(self: BackgroundTaskFinishedEvent): any {
+    return {
+      data: BackgroundTaskFinishedEvent2Serializer._toJsonObject(self.data),
+      type: self.type,
+    };
+  },
+};

node_modules/svix/src/models/backgroundTaskFinishedEvent2.ts

@@ -0,0 +1,37 @@
+// this file is @generated
+import {
+  type BackgroundTaskStatus,
+  BackgroundTaskStatusSerializer,
+} from "./backgroundTaskStatus";
+import {
+  type BackgroundTaskType,
+  BackgroundTaskTypeSerializer,
+} from "./backgroundTaskType";
+
+export interface BackgroundTaskFinishedEvent2 {
+  data: any;
+  status: BackgroundTaskStatus;
+  task: BackgroundTaskType;
+  /** The QueueBackgroundTask's ID. */
+  taskId: string;
+}
+
+export const BackgroundTaskFinishedEvent2Serializer = {
+  _fromJsonObject(object: any): BackgroundTaskFinishedEvent2 {
+    return {
+      data: object["data"],
+      status: BackgroundTaskStatusSerializer._fromJsonObject(object["status"]),
+      task: BackgroundTaskTypeSerializer._fromJsonObject(object["task"]),
+      taskId: object["taskId"],
+    };
+  },
+
+  _toJsonObject(self: BackgroundTaskFinishedEvent2): any {
+    return {
+      data: self.data,
+      status: BackgroundTaskStatusSerializer._toJsonObject(self.status),
+      task: BackgroundTaskTypeSerializer._toJsonObject(self.task),
+      taskId: self.taskId,
+    };
+  },
+};

node_modules/svix/src/models/backgroundTaskOut.ts

@@ -0,0 +1,40 @@
+// this file is @generated
+import {
+  type BackgroundTaskStatus,
+  BackgroundTaskStatusSerializer,
+} from "./backgroundTaskStatus";
+import {
+  type BackgroundTaskType,
+  BackgroundTaskTypeSerializer,
+} from "./backgroundTaskType";
+
+export interface BackgroundTaskOut {
+  data: any;
+  /** The QueueBackgroundTask's ID. */
+  id: string;
+  status: BackgroundTaskStatus;
+  task: BackgroundTaskType;
+  updatedAt: Date;
+}
+
+export const BackgroundTaskOutSerializer = {
+  _fromJsonObject(object: any): BackgroundTaskOut {
+    return {
+      data: object["data"],
+      id: object["id"],
+      status: BackgroundTaskStatusSerializer._fromJsonObject(object["status"]),
+      task: BackgroundTaskTypeSerializer._fromJsonObject(object["task"]),
+      updatedAt: new Date(object["updatedAt"]),
+    };
+  },
+
+  _toJsonObject(self: BackgroundTaskOut): any {
+    return {
+      data: self.data,
+      id: self.id,
+      status: BackgroundTaskStatusSerializer._toJsonObject(self.status),
+      task: BackgroundTaskTypeSerializer._toJsonObject(self.task),
+      updatedAt: self.updatedAt,
+    };
+  },
+};

node_modules/svix/src/models/backgroundTaskStatus.ts

@@ -0,0 +1,17 @@
+// this file is @generated
+
+export enum BackgroundTaskStatus {
+  Running = "running",
+  Finished = "finished",
+  Failed = "failed",
+}
+
+export const BackgroundTaskStatusSerializer = {
+  _fromJsonObject(object: any): BackgroundTaskStatus {
+    return object;
+  },
+
+  _toJsonObject(self: BackgroundTaskStatus): any {
+    return self;
+  },
+};

node_modules/svix/src/models/backgroundTaskType.ts

@@ -0,0 +1,22 @@
+// this file is @generated
+
+export enum BackgroundTaskType {
+  EndpointReplay = "endpoint.replay",
+  EndpointRecover = "endpoint.recover",
+  ApplicationStats = "application.stats",
+  MessageBroadcast = "message.broadcast",
+  SdkGenerate = "sdk.generate",
+  EventTypeAggregate = "event-type.aggregate",
+  ApplicationPurgeContent = "application.purge_content",
+  EndpointBulkReplay = "endpoint.bulk-replay",
+}
+
+export const BackgroundTaskTypeSerializer = {
+  _fromJsonObject(object: any): BackgroundTaskType {
+    return object;
+  },
+
+  _toJsonObject(self: BackgroundTaskType): any {
+    return self;
+  },
+};

node_modules/svix/src/models/bulkReplayIn.ts

@@ -0,0 +1,51 @@
+// this file is @generated
+import { type MessageStatus, MessageStatusSerializer } from "./messageStatus";
+import { type StatusCodeClass, StatusCodeClassSerializer } from "./statusCodeClass";
+
+export interface BulkReplayIn {
+  channel?: string | null;
+  eventTypes?: string[] | null;
+  since: Date;
+  status?: MessageStatus | null;
+  statusCodeClass?: StatusCodeClass | null;
+  tag?: string | null;
+  until?: Date | null;
+}
+
+export const BulkReplayInSerializer = {
+  _fromJsonObject(object: any): BulkReplayIn {
+    return {
+      channel: object["channel"],
+      eventTypes: object["eventTypes"],
+      since: new Date(object["since"]),
+      status:
+        object["status"] != null
+          ? MessageStatusSerializer._fromJsonObject(object["status"])
+          : undefined,
+      statusCodeClass:
+        object["statusCodeClass"] != null
+          ? StatusCodeClassSerializer._fromJsonObject(object["statusCodeClass"])
+          : undefined,
+      tag: object["tag"],
+      until: object["until"] ? new Date(object["until"]) : null,
+    };
+  },
+
+  _toJsonObject(self: BulkReplayIn): any {
+    return {
+      channel: self.channel,
+      eventTypes: self.eventTypes,
+      since: self.since,
+      status:
+        self.status != null
+          ? MessageStatusSerializer._toJsonObject(self.status)
+          : undefined,
+      statusCodeClass:
+        self.statusCodeClass != null
+          ? StatusCodeClassSerializer._toJsonObject(self.statusCodeClass)
+          : undefined,
+      tag: self.tag,
+      until: self.until,
+    };
+  },
+};

node_modules/svix/src/models/checkbookConfig.ts

@@ -0,0 +1,19 @@
+// this file is @generated
+
+export interface CheckbookConfig {
+  secret: string;
+}
+
+export const CheckbookConfigSerializer = {
+  _fromJsonObject(object: any): CheckbookConfig {
+    return {
+      secret: object["secret"],
+    };
+  },
+
+  _toJsonObject(self: CheckbookConfig): any {
+    return {
+      secret: self.secret,
+    };
+  },
+};

node_modules/svix/src/models/checkbookConfigOut.ts

@@ -0,0 +1,15 @@
+// this file is @generated
+
+// biome-ignore-all lint/suspicious/noEmptyInterface: backwards compat
+
+export interface CheckbookConfigOut {}
+
+export const CheckbookConfigOutSerializer = {
+  _fromJsonObject(_object: any): CheckbookConfigOut {
+    return {};
+  },
+
+  _toJsonObject(_self: CheckbookConfigOut): any {
+    return {};
+  },
+};

node_modules/svix/src/models/connectorIn.ts

@@ -0,0 +1,59 @@
+// this file is @generated
+import { type ConnectorKind, ConnectorKindSerializer } from "./connectorKind";
+import { type ConnectorProduct, ConnectorProductSerializer } from "./connectorProduct";
+
+export interface ConnectorIn {
+  allowedEventTypes?: string[] | null;
+  description?: string;
+  featureFlags?: string[] | null;
+  instructions?: string;
+  kind?: ConnectorKind;
+  logo?: string | null;
+  name: string;
+  productType?: ConnectorProduct | null;
+  transformation: string;
+  /** The Connector's UID. */
+  uid?: string | null;
+}
+
+export const ConnectorInSerializer = {
+  _fromJsonObject(object: any): ConnectorIn {
+    return {
+      allowedEventTypes: object["allowedEventTypes"],
+      description: object["description"],
+      featureFlags: object["featureFlags"],
+      instructions: object["instructions"],
+      kind:
+        object["kind"] != null
+          ? ConnectorKindSerializer._fromJsonObject(object["kind"])
+          : undefined,
+      logo: object["logo"],
+      name: object["name"],
+      productType:
+        object["productType"] != null
+          ? ConnectorProductSerializer._fromJsonObject(object["productType"])
+          : undefined,
+      transformation: object["transformation"],
+      uid: object["uid"],
+    };
+  },
+
+  _toJsonObject(self: ConnectorIn): any {
+    return {
+      allowedEventTypes: self.allowedEventTypes,
+      description: self.description,
+      featureFlags: self.featureFlags,
+      instructions: self.instructions,
+      kind:
+        self.kind != null ? ConnectorKindSerializer._toJsonObject(self.kind) : undefined,
+      logo: self.logo,
+      name: self.name,
+      productType:
+        self.productType != null
+          ? ConnectorProductSerializer._toJsonObject(self.productType)
+          : undefined,
+      transformation: self.transformation,
+      uid: self.uid,
+    };
+  },
+};

node_modules/svix/src/models/connectorKind.ts

@@ -0,0 +1,32 @@
+// this file is @generated
+
+export enum ConnectorKind {
+  Custom = "Custom",
+  AgenticCommerceProtocol = "AgenticCommerceProtocol",
+  CloseCrm = "CloseCRM",
+  CustomerIo = "CustomerIO",
+  Discord = "Discord",
+  Hubspot = "Hubspot",
+  Inngest = "Inngest",
+  Loops = "Loops",
+  Otel = "Otel",
+  Resend = "Resend",
+  Salesforce = "Salesforce",
+  Segment = "Segment",
+  Sendgrid = "Sendgrid",
+  Slack = "Slack",
+  Teams = "Teams",
+  TriggerDev = "TriggerDev",
+  Windmill = "Windmill",
+  Zapier = "Zapier",
+}
+
+export const ConnectorKindSerializer = {
+  _fromJsonObject(object: any): ConnectorKind {
+    return object;
+  },
+
+  _toJsonObject(self: ConnectorKind): any {
+    return self;
+  },
+};

node_modules/svix/src/models/connectorOut.ts

@@ -0,0 +1,66 @@
+// this file is @generated
+import { type ConnectorKind, ConnectorKindSerializer } from "./connectorKind";
+import { type ConnectorProduct, ConnectorProductSerializer } from "./connectorProduct";
+
+export interface ConnectorOut {
+  allowedEventTypes?: string[] | null;
+  createdAt: Date;
+  description: string;
+  featureFlags?: string[] | null;
+  /** The Connector's ID. */
+  id: string;
+  instructions: string;
+  kind: ConnectorKind;
+  logo?: string | null;
+  name: string;
+  /** The Environment's ID. */
+  orgId: string;
+  productType: ConnectorProduct;
+  transformation: string;
+  transformationUpdatedAt: Date;
+  /** The Connector's UID. */
+  uid?: string | null;
+  updatedAt: Date;
+}
+
+export const ConnectorOutSerializer = {
+  _fromJsonObject(object: any): ConnectorOut {
+    return {
+      allowedEventTypes: object["allowedEventTypes"],
+      createdAt: new Date(object["createdAt"]),
+      description: object["description"],
+      featureFlags: object["featureFlags"],
+      id: object["id"],
+      instructions: object["instructions"],
+      kind: ConnectorKindSerializer._fromJsonObject(object["kind"]),
+      logo: object["logo"],
+      name: object["name"],
+      orgId: object["orgId"],
+      productType: ConnectorProductSerializer._fromJsonObject(object["productType"]),
+      transformation: object["transformation"],
+      transformationUpdatedAt: new Date(object["transformationUpdatedAt"]),
+      uid: object["uid"],
+      updatedAt: new Date(object["updatedAt"]),
+    };
+  },
+
+  _toJsonObject(self: ConnectorOut): any {
+    return {
+      allowedEventTypes: self.allowedEventTypes,
+      createdAt: self.createdAt,
+      description: self.description,
+      featureFlags: self.featureFlags,
+      id: self.id,
+      instructions: self.instructions,
+      kind: ConnectorKindSerializer._toJsonObject(self.kind),
+      logo: self.logo,
+      name: self.name,
+      orgId: self.orgId,
+      productType: ConnectorProductSerializer._toJsonObject(self.productType),
+      transformation: self.transformation,
+      transformationUpdatedAt: self.transformationUpdatedAt,
+      uid: self.uid,
+      updatedAt: self.updatedAt,
+    };
+  },
+};

node_modules/svix/src/models/connectorPatch.ts

@@ -0,0 +1,45 @@
+// this file is @generated
+import { type ConnectorKind, ConnectorKindSerializer } from "./connectorKind";
+
+export interface ConnectorPatch {
+  allowedEventTypes?: string[] | null;
+  description?: string;
+  featureFlags?: string[] | null;
+  instructions?: string;
+  kind?: ConnectorKind;
+  logo?: string | null;
+  name?: string;
+  transformation?: string;
+}
+
+export const ConnectorPatchSerializer = {
+  _fromJsonObject(object: any): ConnectorPatch {
+    return {
+      allowedEventTypes: object["allowedEventTypes"],
+      description: object["description"],
+      featureFlags: object["featureFlags"],
+      instructions: object["instructions"],
+      kind:
+        object["kind"] != null
+          ? ConnectorKindSerializer._fromJsonObject(object["kind"])
+          : undefined,
+      logo: object["logo"],
+      name: object["name"],
+      transformation: object["transformation"],
+    };
+  },
+
+  _toJsonObject(self: ConnectorPatch): any {
+    return {
+      allowedEventTypes: self.allowedEventTypes,
+      description: self.description,
+      featureFlags: self.featureFlags,
+      instructions: self.instructions,
+      kind:
+        self.kind != null ? ConnectorKindSerializer._toJsonObject(self.kind) : undefined,
+      logo: self.logo,
+      name: self.name,
+      transformation: self.transformation,
+    };
+  },
+};

node_modules/svix/src/models/connectorProduct.ts

@@ -0,0 +1,16 @@
+// this file is @generated
+
+export enum ConnectorProduct {
+  Dispatch = "Dispatch",
+  Stream = "Stream",
+}
+
+export const ConnectorProductSerializer = {
+  _fromJsonObject(object: any): ConnectorProduct {
+    return object;
+  },
+
+  _toJsonObject(self: ConnectorProduct): any {
+    return self;
+  },
+};

node_modules/svix/src/models/connectorUpdate.ts

@@ -0,0 +1,45 @@
+// this file is @generated
+import { type ConnectorKind, ConnectorKindSerializer } from "./connectorKind";
+
+export interface ConnectorUpdate {
+  allowedEventTypes?: string[] | null;
+  description?: string;
+  featureFlags?: string[] | null;
+  instructions?: string;
+  kind?: ConnectorKind;
+  logo?: string | null;
+  name?: string;
+  transformation: string;
+}
+
+export const ConnectorUpdateSerializer = {
+  _fromJsonObject(object: any): ConnectorUpdate {
+    return {
+      allowedEventTypes: object["allowedEventTypes"],
+      description: object["description"],
+      featureFlags: object["featureFlags"],
+      instructions: object["instructions"],
+      kind:
+        object["kind"] != null
+          ? ConnectorKindSerializer._fromJsonObject(object["kind"])
+          : undefined,
+      logo: object["logo"],
+      name: object["name"],
+      transformation: object["transformation"],
+    };
+  },
+
+  _toJsonObject(self: ConnectorUpdate): any {
+    return {
+      allowedEventTypes: self.allowedEventTypes,
+      description: self.description,
+      featureFlags: self.featureFlags,
+      instructions: self.instructions,
+      kind:
+        self.kind != null ? ConnectorKindSerializer._toJsonObject(self.kind) : undefined,
+      logo: self.logo,
+      name: self.name,
+      transformation: self.transformation,
+    };
+  },
+};

node_modules/svix/src/models/createStreamEventsIn.ts

@@ -0,0 +1,35 @@
+// this file is @generated
+import { type EventIn, EventInSerializer } from "./eventIn";
+import { type StreamIn, StreamInSerializer } from "./streamIn";
+
+export interface CreateStreamEventsIn {
+  events: EventIn[];
+  /**
+   * Optionally creates a new Stream alongside the events.
+   *
+   * If the stream id or uid that is used in the path already exists, this argument is ignored.
+   */
+  stream?: StreamIn | null;
+}
+
+export const CreateStreamEventsInSerializer = {
+  _fromJsonObject(object: any): CreateStreamEventsIn {
+    return {
+      events: object["events"].map((item: EventIn) =>
+        EventInSerializer._fromJsonObject(item)
+      ),
+      stream:
+        object["stream"] != null
+          ? StreamInSerializer._fromJsonObject(object["stream"])
+          : undefined,
+    };
+  },
+
+  _toJsonObject(self: CreateStreamEventsIn): any {
+    return {
+      events: self.events.map((item) => EventInSerializer._toJsonObject(item)),
+      stream:
+        self.stream != null ? StreamInSerializer._toJsonObject(self.stream) : undefined,
+    };
+  },
+};

node_modules/svix/src/models/createStreamEventsOut.ts

@@ -0,0 +1,15 @@
+// this file is @generated
+
+// biome-ignore-all lint/suspicious/noEmptyInterface: backwards compat
+
+export interface CreateStreamEventsOut {}
+
+export const CreateStreamEventsOutSerializer = {
+  _fromJsonObject(_object: any): CreateStreamEventsOut {
+    return {};
+  },
+
+  _toJsonObject(_self: CreateStreamEventsOut): any {
+    return {};
+  },
+};

node_modules/svix/src/models/cronConfig.ts

@@ -0,0 +1,30 @@
+// this file is @generated
+
+export interface CronConfig {
+  /**
+   * Override the default content-type.
+   *
+   * Recommended if the payload is not JSON.
+   */
+  contentType?: string | null;
+  payload: string;
+  schedule: string;
+}
+
+export const CronConfigSerializer = {
+  _fromJsonObject(object: any): CronConfig {
+    return {
+      contentType: object["contentType"],
+      payload: object["payload"],
+      schedule: object["schedule"],
+    };
+  },
+
+  _toJsonObject(self: CronConfig): any {
+    return {
+      contentType: self.contentType,
+      payload: self.payload,
+      schedule: self.schedule,
+    };
+  },
+};

node_modules/svix/src/models/dashboardAccessOut.ts

@@ -0,0 +1,22 @@
+// this file is @generated
+
+export interface DashboardAccessOut {
+  token: string;
+  url: string;
+}
+
+export const DashboardAccessOutSerializer = {
+  _fromJsonObject(object: any): DashboardAccessOut {
+    return {
+      token: object["token"],
+      url: object["url"],
+    };
+  },
+
+  _toJsonObject(self: DashboardAccessOut): any {
+    return {
+      token: self.token,
+      url: self.url,
+    };
+  },
+};

node_modules/svix/src/models/docusignConfig.ts

@@ -0,0 +1,19 @@
+// this file is @generated
+
+export interface DocusignConfig {
+  secret?: string | null;
+}
+
+export const DocusignConfigSerializer = {
+  _fromJsonObject(object: any): DocusignConfig {
+    return {
+      secret: object["secret"],
+    };
+  },
+
+  _toJsonObject(self: DocusignConfig): any {
+    return {
+      secret: self.secret,
+    };
+  },
+};

node_modules/svix/src/models/docusignConfigOut.ts

@@ -0,0 +1,15 @@
+// this file is @generated
+
+// biome-ignore-all lint/suspicious/noEmptyInterface: backwards compat
+
+export interface DocusignConfigOut {}
+
+export const DocusignConfigOutSerializer = {
+  _fromJsonObject(_object: any): DocusignConfigOut {
+    return {};
+  },
+
+  _toJsonObject(_self: DocusignConfigOut): any {
+    return {};
+  },
+};

node_modules/svix/src/models/easypostConfig.ts

@@ -0,0 +1,19 @@
+// this file is @generated
+
+export interface EasypostConfig {
+  secret?: string | null;
+}
+
+export const EasypostConfigSerializer = {
+  _fromJsonObject(object: any): EasypostConfig {
+    return {
+      secret: object["secret"],
+    };
+  },
+
+  _toJsonObject(self: EasypostConfig): any {
+    return {
+      secret: self.secret,
+    };
+  },
+};

node_modules/svix/src/models/easypostConfigOut.ts

@@ -0,0 +1,15 @@
+// this file is @generated
+
+// biome-ignore-all lint/suspicious/noEmptyInterface: backwards compat
+
+export interface EasypostConfigOut {}
+
+export const EasypostConfigOutSerializer = {
+  _fromJsonObject(_object: any): EasypostConfigOut {
+    return {};
+  },
+
+  _toJsonObject(_self: EasypostConfigOut): any {
+    return {};
+  },
+};

node_modules/svix/src/models/emptyResponse.ts

@@ -0,0 +1,15 @@
+// this file is @generated
+
+// biome-ignore-all lint/suspicious/noEmptyInterface: backwards compat
+
+export interface EmptyResponse {}
+
+export const EmptyResponseSerializer = {
+  _fromJsonObject(_object: any): EmptyResponse {
+    return {};
+  },
+
+  _toJsonObject(_self: EmptyResponse): any {
+    return {};
+  },
+};

node_modules/svix/src/models/endpointCreatedEvent.ts

@@ -0,0 +1,27 @@
+// this file is @generated
+import {
+  type EndpointCreatedEventData,
+  EndpointCreatedEventDataSerializer,
+} from "./endpointCreatedEventData";
+
+/** Sent when an endpoint is created. */
+export interface EndpointCreatedEvent {
+  data: EndpointCreatedEventData;
+  type: string;
+}
+
+export const EndpointCreatedEventSerializer = {
+  _fromJsonObject(object: any): EndpointCreatedEvent {
+    return {
+      data: EndpointCreatedEventDataSerializer._fromJsonObject(object["data"]),
+      type: object["type"],
+    };
+  },
+
+  _toJsonObject(self: EndpointCreatedEvent): any {
+    return {
+      data: EndpointCreatedEventDataSerializer._toJsonObject(self.data),
+      type: self.type,
+    };
+  },
+};

node_modules/svix/src/models/endpointCreatedEventData.ts

@@ -0,0 +1,33 @@
+// this file is @generated
+
+/** Sent when an endpoint is created, updated, or deleted */
+export interface EndpointCreatedEventData {
+  /** The Application's ID. */
+  appId: string;
+  /** The Application's UID. */
+  appUid?: string | null;
+  /** The Endpoint's ID. */
+  endpointId: string;
+  /** The Endpoint's UID. */
+  endpointUid?: string | null;
+}
+
+export const EndpointCreatedEventDataSerializer = {
+  _fromJsonObject(object: any): EndpointCreatedEventData {
+    return {
+      appId: object["appId"],
+      appUid: object["appUid"],
+      endpointId: object["endpointId"],
+      endpointUid: object["endpointUid"],
+    };
+  },
+
+  _toJsonObject(self: EndpointCreatedEventData): any {
+    return {
+      appId: self.appId,
+      appUid: self.appUid,
+      endpointId: self.endpointId,
+      endpointUid: self.endpointUid,
+    };
+  },
+};

node_modules/svix/src/models/endpointDeletedEvent.ts

@@ -0,0 +1,27 @@
+// this file is @generated
+import {
+  type EndpointDeletedEventData,
+  EndpointDeletedEventDataSerializer,
+} from "./endpointDeletedEventData";
+
+/** Sent when an endpoint is deleted. */
+export interface EndpointDeletedEvent {
+  data: EndpointDeletedEventData;
+  type: string;
+}
+
+export const EndpointDeletedEventSerializer = {
+  _fromJsonObject(object: any): EndpointDeletedEvent {
+    return {
+      data: EndpointDeletedEventDataSerializer._fromJsonObject(object["data"]),
+      type: object["type"],
+    };
+  },
+
+  _toJsonObject(self: EndpointDeletedEvent): any {
+    return {
+      data: EndpointDeletedEventDataSerializer._toJsonObject(self.data),
+      type: self.type,
+    };
+  },
+};

node_modules/svix/src/models/endpointDeletedEventData.ts

@@ -0,0 +1,33 @@
+// this file is @generated
+
+/** Sent when an endpoint is created, updated, or deleted */
+export interface EndpointDeletedEventData {
+  /** The Application's ID. */
+  appId: string;
+  /** The Application's UID. */
+  appUid?: string | null;
+  /** The Endpoint's ID. */
+  endpointId: string;
+  /** The Endpoint's UID. */
+  endpointUid?: string | null;
+}
+
+export const EndpointDeletedEventDataSerializer = {
+  _fromJsonObject(object: any): EndpointDeletedEventData {
+    return {
+      appId: object["appId"],
+      appUid: object["appUid"],
+      endpointId: object["endpointId"],
+      endpointUid: object["endpointUid"],
+    };
+  },
+
+  _toJsonObject(self: EndpointDeletedEventData): any {
+    return {
+      appId: self.appId,
+      appUid: self.appUid,
+      endpointId: self.endpointId,
+      endpointUid: self.endpointUid,
+    };
+  },
+};

node_modules/svix/src/models/endpointDisabledEvent.ts

@@ -0,0 +1,27 @@
+// this file is @generated
+import {
+  type EndpointDisabledEventData,
+  EndpointDisabledEventDataSerializer,
+} from "./endpointDisabledEventData";
+
+/** Sent when an endpoint has been automatically disabled after continuous failures, or manually via an API call. */
+export interface EndpointDisabledEvent {
+  data: EndpointDisabledEventData;
+  type: string;
+}
+
+export const EndpointDisabledEventSerializer = {
+  _fromJsonObject(object: any): EndpointDisabledEvent {
+    return {
+      data: EndpointDisabledEventDataSerializer._fromJsonObject(object["data"]),
+      type: object["type"],
+    };
+  },
+
+  _toJsonObject(self: EndpointDisabledEvent): any {
+    return {
+      data: EndpointDisabledEventDataSerializer._toJsonObject(self.data),
+      type: self.type,
+    };
+  },
+};

node_modules/svix/src/models/endpointDisabledEventData.ts

@@ -0,0 +1,49 @@
+// this file is @generated
+import {
+  type EndpointDisabledTrigger,
+  EndpointDisabledTriggerSerializer,
+} from "./endpointDisabledTrigger";
+
+/** Sent when an endpoint has been automatically disabled after continuous failures, or manually via an API call. */
+export interface EndpointDisabledEventData {
+  /** The Application's ID. */
+  appId: string;
+  /** The Application's UID. */
+  appUid?: string | null;
+  /** The Endpoint's ID. */
+  endpointId: string;
+  /** The Endpoint's UID. */
+  endpointUid?: string | null;
+  failSince?: Date | null;
+  trigger?: EndpointDisabledTrigger;
+}
+
+export const EndpointDisabledEventDataSerializer = {
+  _fromJsonObject(object: any): EndpointDisabledEventData {
+    return {
+      appId: object["appId"],
+      appUid: object["appUid"],
+      endpointId: object["endpointId"],
+      endpointUid: object["endpointUid"],
+      failSince: object["failSince"] ? new Date(object["failSince"]) : null,
+      trigger:
+        object["trigger"] != null
+          ? EndpointDisabledTriggerSerializer._fromJsonObject(object["trigger"])
+          : undefined,
+    };
+  },
+
+  _toJsonObject(self: EndpointDisabledEventData): any {
+    return {
+      appId: self.appId,
+      appUid: self.appUid,
+      endpointId: self.endpointId,
+      endpointUid: self.endpointUid,
+      failSince: self.failSince,
+      trigger:
+        self.trigger != null
+          ? EndpointDisabledTriggerSerializer._toJsonObject(self.trigger)
+          : undefined,
+    };
+  },
+};

node_modules/svix/src/models/endpointDisabledTrigger.ts

@@ -0,0 +1,16 @@
+// this file is @generated
+
+export enum EndpointDisabledTrigger {
+  Manual = "manual",
+  Automatic = "automatic",
+}
+
+export const EndpointDisabledTriggerSerializer = {
+  _fromJsonObject(object: any): EndpointDisabledTrigger {
+    return object;
+  },
+
+  _toJsonObject(self: EndpointDisabledTrigger): any {
+    return self;
+  },
+};

node_modules/svix/src/models/endpointEnabledEvent.ts

@@ -0,0 +1,27 @@
+// this file is @generated
+import {
+  type EndpointEnabledEventData,
+  EndpointEnabledEventDataSerializer,
+} from "./endpointEnabledEventData";
+
+/** Sent when an endpoint has been enabled. */
+export interface EndpointEnabledEvent {
+  data: EndpointEnabledEventData;
+  type: string;
+}
+
+export const EndpointEnabledEventSerializer = {
+  _fromJsonObject(object: any): EndpointEnabledEvent {
+    return {
+      data: EndpointEnabledEventDataSerializer._fromJsonObject(object["data"]),
+      type: object["type"],
+    };
+  },
+
+  _toJsonObject(self: EndpointEnabledEvent): any {
+    return {
+      data: EndpointEnabledEventDataSerializer._toJsonObject(self.data),
+      type: self.type,
+    };
+  },
+};

node_modules/svix/src/models/endpointEnabledEventData.ts

@@ -0,0 +1,33 @@
+// this file is @generated
+
+/** Sent when an endpoint has been enabled. */
+export interface EndpointEnabledEventData {
+  /** The Application's ID. */
+  appId: string;
+  /** The Application's UID. */
+  appUid?: string | null;
+  /** The Endpoint's ID. */
+  endpointId: string;
+  /** The Endpoint's UID. */
+  endpointUid?: string | null;
+}
+
+export const EndpointEnabledEventDataSerializer = {
+  _fromJsonObject(object: any): EndpointEnabledEventData {
+    return {
+      appId: object["appId"],
+      appUid: object["appUid"],
+      endpointId: object["endpointId"],
+      endpointUid: object["endpointUid"],
+    };
+  },
+
+  _toJsonObject(self: EndpointEnabledEventData): any {
+    return {
+      appId: self.appId,
+      appUid: self.appUid,
+      endpointId: self.endpointId,
+      endpointUid: self.endpointUid,
+    };
+  },
+};

node_modules/svix/src/models/endpointHeadersIn.ts

@@ -0,0 +1,19 @@
+// this file is @generated
+
+export interface EndpointHeadersIn {
+  headers: { [key: string]: string };
+}
+
+export const EndpointHeadersInSerializer = {
+  _fromJsonObject(object: any): EndpointHeadersIn {
+    return {
+      headers: object["headers"],
+    };
+  },
+
+  _toJsonObject(self: EndpointHeadersIn): any {
+    return {
+      headers: self.headers,
+    };
+  },
+};

node_modules/svix/src/models/endpointHeadersOut.ts

@@ -0,0 +1,27 @@
+// this file is @generated
+
+/**
+ * The value of the headers is returned in the `headers` field.
+ *
+ * Sensitive headers that have been redacted are returned in the sensitive field.
+ */
+export interface EndpointHeadersOut {
+  headers: { [key: string]: string };
+  sensitive: string[];
+}
+
+export const EndpointHeadersOutSerializer = {
+  _fromJsonObject(object: any): EndpointHeadersOut {
+    return {
+      headers: object["headers"],
+      sensitive: object["sensitive"],
+    };
+  },
+
+  _toJsonObject(self: EndpointHeadersOut): any {
+    return {
+      headers: self.headers,
+      sensitive: self.sensitive,
+    };
+  },
+};

node_modules/svix/src/models/endpointHeadersPatchIn.ts

@@ -0,0 +1,23 @@
+// this file is @generated
+
+export interface EndpointHeadersPatchIn {
+  /** A list of headers be be removed */
+  deleteHeaders?: string[];
+  headers: { [key: string]: string };
+}
+
+export const EndpointHeadersPatchInSerializer = {
+  _fromJsonObject(object: any): EndpointHeadersPatchIn {
+    return {
+      deleteHeaders: object["deleteHeaders"],
+      headers: object["headers"],
+    };
+  },
+
+  _toJsonObject(self: EndpointHeadersPatchIn): any {
+    return {
+      deleteHeaders: self.deleteHeaders,
+      headers: self.headers,
+    };
+  },
+};

node_modules/svix/src/models/endpointIn.ts

@@ -0,0 +1,70 @@
+// this file is @generated
+
+export interface EndpointIn {
+  /** List of message channels this endpoint listens to (omit for all). */
+  channels?: string[] | null;
+  description?: string;
+  disabled?: boolean;
+  filterTypes?: string[] | null;
+  headers?: { [key: string]: string } | null;
+  metadata?: { [key: string]: string };
+  /**
+   * Deprecated, use `throttleRate` instead.
+   *
+   * @deprecated
+   */
+  rateLimit?: number | null;
+  /**
+   * The endpoint's verification secret.
+   *
+   * Format: `base64` encoded random bytes optionally prefixed with `whsec_`.
+   * It is recommended to not set this and let the server generate the secret.
+   */
+  secret?: string | null;
+  /**
+   * Maximum messages per second to send to this endpoint.
+   *
+   * Outgoing messages will be throttled to this rate.
+   */
+  throttleRate?: number | null;
+  /** Optional unique identifier for the endpoint. */
+  uid?: string | null;
+  url: string;
+  version?: number | null;
+}
+
+export const EndpointInSerializer = {
+  _fromJsonObject(object: any): EndpointIn {
+    return {
+      channels: object["channels"],
+      description: object["description"],
+      disabled: object["disabled"],
+      filterTypes: object["filterTypes"],
+      headers: object["headers"],
+      metadata: object["metadata"],
+      rateLimit: object["rateLimit"],
+      secret: object["secret"],
+      throttleRate: object["throttleRate"],
+      uid: object["uid"],
+      url: object["url"],
+      version: object["version"],
+    };
+  },
+
+  _toJsonObject(self: EndpointIn): any {
+    return {
+      channels: self.channels,
+      description: self.description,
+      disabled: self.disabled,
+      filterTypes: self.filterTypes,
+      headers: self.headers,
+      metadata: self.metadata,
+      rateLimit: self.rateLimit,
+      secret: self.secret,
+      throttleRate: self.throttleRate,
+      uid: self.uid,
+      url: self.url,
+      version: self.version,
+    };
+  },
+};

node_modules/svix/src/models/endpointMessageOut.ts

@@ -0,0 +1,56 @@
+// this file is @generated
+import { type MessageStatus, MessageStatusSerializer } from "./messageStatus";
+import { type MessageStatusText, MessageStatusTextSerializer } from "./messageStatusText";
+
+/** A model containing information on a given message plus additional fields on the last attempt for that message. */
+export interface EndpointMessageOut {
+  /** List of free-form identifiers that endpoints can filter by */
+  channels?: string[] | null;
+  deliverAt?: Date | null;
+  /** Optional unique identifier for the message */
+  eventId?: string | null;
+  /** The event type's name */
+  eventType: string;
+  /** The Message's ID. */
+  id: string;
+  nextAttempt?: Date | null;
+  payload: any;
+  status: MessageStatus;
+  statusText: MessageStatusText;
+  tags?: string[] | null;
+  timestamp: Date;
+}
+
+export const EndpointMessageOutSerializer = {
+  _fromJsonObject(object: any): EndpointMessageOut {
+    return {
+      channels: object["channels"],
+      deliverAt: object["deliverAt"] ? new Date(object["deliverAt"]) : null,
+      eventId: object["eventId"],
+      eventType: object["eventType"],
+      id: object["id"],
+      nextAttempt: object["nextAttempt"] ? new Date(object["nextAttempt"]) : null,
+      payload: object["payload"],
+      status: MessageStatusSerializer._fromJsonObject(object["status"]),
+      statusText: MessageStatusTextSerializer._fromJsonObject(object["statusText"]),
+      tags: object["tags"],
+      timestamp: new Date(object["timestamp"]),
+    };
+  },
+
+  _toJsonObject(self: EndpointMessageOut): any {
+    return {
+      channels: self.channels,
+      deliverAt: self.deliverAt,
+      eventId: self.eventId,
+      eventType: self.eventType,
+      id: self.id,
+      nextAttempt: self.nextAttempt,
+      payload: self.payload,
+      status: MessageStatusSerializer._toJsonObject(self.status),
+      statusText: MessageStatusTextSerializer._toJsonObject(self.statusText),
+      tags: self.tags,
+      timestamp: self.timestamp,
+    };
+  },
+};

node_modules/svix/src/models/endpointOut.ts

@@ -0,0 +1,65 @@
+// this file is @generated
+
+export interface EndpointOut {
+  /** List of message channels this endpoint listens to (omit for all). */
+  channels?: string[] | null;
+  createdAt: Date;
+  /** An example endpoint name. */
+  description: string;
+  disabled?: boolean;
+  filterTypes?: string[] | null;
+  /** The Endpoint's ID. */
+  id: string;
+  metadata: { [key: string]: string };
+  /**
+   * Deprecated, use `throttleRate` instead.
+   *
+   * @deprecated
+   */
+  rateLimit?: number | null;
+  /** Maximum messages per second to send to this endpoint. Outgoing messages will be throttled to this rate. */
+  throttleRate?: number | null;
+  /** Optional unique identifier for the endpoint. */
+  uid?: string | null;
+  updatedAt: Date;
+  url: string;
+  version: number;
+}
+
+export const EndpointOutSerializer = {
+  _fromJsonObject(object: any): EndpointOut {
+    return {
+      channels: object["channels"],
+      createdAt: new Date(object["createdAt"]),
+      description: object["description"],
+      disabled: object["disabled"],
+      filterTypes: object["filterTypes"],
+      id: object["id"],
+      metadata: object["metadata"],
+      rateLimit: object["rateLimit"],
+      throttleRate: object["throttleRate"],
+      uid: object["uid"],
+      updatedAt: new Date(object["updatedAt"]),
+      url: object["url"],
+      version: object["version"],
+    };
+  },
+
+  _toJsonObject(self: EndpointOut): any {
+    return {
+      channels: self.channels,
+      createdAt: self.createdAt,
+      description: self.description,
+      disabled: self.disabled,
+      filterTypes: self.filterTypes,
+      id: self.id,
+      metadata: self.metadata,
+      rateLimit: self.rateLimit,
+      throttleRate: self.throttleRate,
+      uid: self.uid,
+      updatedAt: self.updatedAt,
+      url: self.url,
+      version: self.version,
+    };
+  },
+};

node_modules/svix/src/models/endpointPatch.ts

@@ -0,0 +1,68 @@
+// this file is @generated
+
+export interface EndpointPatch {
+  channels?: string[] | null;
+  description?: string;
+  disabled?: boolean;
+  filterTypes?: string[] | null;
+  metadata?: { [key: string]: string };
+  /**
+   * Deprecated, use `throttleRate` instead.
+   *
+   * @deprecated
+   */
+  rateLimit?: number | null;
+  /**
+   * The endpoint's verification secret.
+   *
+   * Format: `base64` encoded random bytes optionally prefixed with `whsec_`.
+   * It is recommended to not set this and let the server generate the secret.
+   *
+   * @deprecated
+   */
+  secret?: string | null;
+  /**
+   * Maximum messages per second to send to this endpoint.
+   *
+   * Outgoing messages will be throttled to this rate.
+   */
+  throttleRate?: number | null;
+  /** The Endpoint's UID. */
+  uid?: string | null;
+  url?: string;
+  version?: number;
+}
+
+export const EndpointPatchSerializer = {
+  _fromJsonObject(object: any): EndpointPatch {
+    return {
+      channels: object["channels"],
+      description: object["description"],
+      disabled: object["disabled"],
+      filterTypes: object["filterTypes"],
+      metadata: object["metadata"],
+      rateLimit: object["rateLimit"],
+      secret: object["secret"],
+      throttleRate: object["throttleRate"],
+      uid: object["uid"],
+      url: object["url"],
+      version: object["version"],
+    };
+  },
+
+  _toJsonObject(self: EndpointPatch): any {
+    return {
+      channels: self.channels,
+      description: self.description,
+      disabled: self.disabled,
+      filterTypes: self.filterTypes,
+      metadata: self.metadata,
+      rateLimit: self.rateLimit,
+      secret: self.secret,
+      throttleRate: self.throttleRate,
+      uid: self.uid,
+      url: self.url,
+      version: self.version,
+    };
+  },
+};

node_modules/svix/src/models/endpointSecretOut.ts

@@ -0,0 +1,25 @@
+// this file is @generated
+
+export interface EndpointSecretOut {
+  /**
+   * The endpoint's verification secret.
+   *
+   * Format: `base64` encoded random bytes optionally prefixed with `whsec_`.
+   * It is recommended to not set this and let the server generate the secret.
+   */
+  key: string;
+}
+
+export const EndpointSecretOutSerializer = {
+  _fromJsonObject(object: any): EndpointSecretOut {
+    return {
+      key: object["key"],
+    };
+  },
+
+  _toJsonObject(self: EndpointSecretOut): any {
+    return {
+      key: self.key,
+    };
+  },
+};

node_modules/svix/src/models/endpointSecretRotateIn.ts

@@ -0,0 +1,25 @@
+// this file is @generated
+
+export interface EndpointSecretRotateIn {
+  /**
+   * The endpoint's verification secret.
+   *
+   * Format: `base64` encoded random bytes optionally prefixed with `whsec_`.
+   * It is recommended to not set this and let the server generate the secret.
+   */
+  key?: string | null;
+}
+
+export const EndpointSecretRotateInSerializer = {
+  _fromJsonObject(object: any): EndpointSecretRotateIn {
+    return {
+      key: object["key"],
+    };
+  },
+
+  _toJsonObject(self: EndpointSecretRotateIn): any {
+    return {
+      key: self.key,
+    };
+  },
+};

node_modules/svix/src/models/endpointStats.ts

@@ -0,0 +1,28 @@
+// this file is @generated
+
+export interface EndpointStats {
+  fail: number;
+  pending: number;
+  sending: number;
+  success: number;
+}
+
+export const EndpointStatsSerializer = {
+  _fromJsonObject(object: any): EndpointStats {
+    return {
+      fail: object["fail"],
+      pending: object["pending"],
+      sending: object["sending"],
+      success: object["success"],
+    };
+  },
+
+  _toJsonObject(self: EndpointStats): any {
+    return {
+      fail: self.fail,
+      pending: self.pending,
+      sending: self.sending,
+      success: self.success,
+    };
+  },
+};

node_modules/svix/src/models/endpointTransformationIn.ts

@@ -0,0 +1,22 @@
+// this file is @generated
+
+export interface EndpointTransformationIn {
+  code?: string | null;
+  enabled?: boolean;
+}
+
+export const EndpointTransformationInSerializer = {
+  _fromJsonObject(object: any): EndpointTransformationIn {
+    return {
+      code: object["code"],
+      enabled: object["enabled"],
+    };
+  },
+
+  _toJsonObject(self: EndpointTransformationIn): any {
+    return {
+      code: self.code,
+      enabled: self.enabled,
+    };
+  },
+};

node_modules/svix/src/models/endpointTransformationOut.ts

@@ -0,0 +1,25 @@
+// this file is @generated
+
+export interface EndpointTransformationOut {
+  code?: string | null;
+  enabled?: boolean;
+  updatedAt?: Date | null;
+}
+
+export const EndpointTransformationOutSerializer = {
+  _fromJsonObject(object: any): EndpointTransformationOut {
+    return {
+      code: object["code"],
+      enabled: object["enabled"],
+      updatedAt: object["updatedAt"] ? new Date(object["updatedAt"]) : null,
+    };
+  },
+
+  _toJsonObject(self: EndpointTransformationOut): any {
+    return {
+      code: self.code,
+      enabled: self.enabled,
+      updatedAt: self.updatedAt,
+    };
+  },
+};

node_modules/svix/src/models/endpointTransformationPatch.ts

@@ -0,0 +1,22 @@
+// this file is @generated
+
+export interface EndpointTransformationPatch {
+  code?: string | null;
+  enabled?: boolean;
+}
+
+export const EndpointTransformationPatchSerializer = {
+  _fromJsonObject(object: any): EndpointTransformationPatch {
+    return {
+      code: object["code"],
+      enabled: object["enabled"],
+    };
+  },
+
+  _toJsonObject(self: EndpointTransformationPatch): any {
+    return {
+      code: self.code,
+      enabled: self.enabled,
+    };
+  },
+};

node_modules/svix/src/models/endpointUpdate.ts

@@ -0,0 +1,58 @@
+// this file is @generated
+
+export interface EndpointUpdate {
+  /** List of message channels this endpoint listens to (omit for all). */
+  channels?: string[] | null;
+  description?: string;
+  disabled?: boolean;
+  filterTypes?: string[] | null;
+  metadata?: { [key: string]: string };
+  /**
+   * Deprecated, use `throttleRate` instead.
+   *
+   * @deprecated
+   */
+  rateLimit?: number | null;
+  /**
+   * Maximum messages per second to send to this endpoint.
+   *
+   * Outgoing messages will be throttled to this rate.
+   */
+  throttleRate?: number | null;
+  /** Optional unique identifier for the endpoint. */
+  uid?: string | null;
+  url: string;
+  version?: number | null;
+}
+
+export const EndpointUpdateSerializer = {
+  _fromJsonObject(object: any): EndpointUpdate {
+    return {
+      channels: object["channels"],
+      description: object["description"],
+      disabled: object["disabled"],
+      filterTypes: object["filterTypes"],
+      metadata: object["metadata"],
+      rateLimit: object["rateLimit"],
+      throttleRate: object["throttleRate"],
+      uid: object["uid"],
+      url: object["url"],
+      version: object["version"],
+    };
+  },
+
+  _toJsonObject(self: EndpointUpdate): any {
+    return {
+      channels: self.channels,
+      description: self.description,
+      disabled: self.disabled,
+      filterTypes: self.filterTypes,
+      metadata: self.metadata,
+      rateLimit: self.rateLimit,
+      throttleRate: self.throttleRate,
+      uid: self.uid,
+      url: self.url,
+      version: self.version,
+    };
+  },
+};

node_modules/svix/src/models/endpointUpdatedEvent.ts

@@ -0,0 +1,27 @@
+// this file is @generated
+import {
+  type EndpointUpdatedEventData,
+  EndpointUpdatedEventDataSerializer,
+} from "./endpointUpdatedEventData";
+
+/** Sent when an endpoint is updated. */
+export interface EndpointUpdatedEvent {
+  data: EndpointUpdatedEventData;
+  type: string;
+}
+
+export const EndpointUpdatedEventSerializer = {
+  _fromJsonObject(object: any): EndpointUpdatedEvent {
+    return {
+      data: EndpointUpdatedEventDataSerializer._fromJsonObject(object["data"]),
+      type: object["type"],
+    };
+  },
+
+  _toJsonObject(self: EndpointUpdatedEvent): any {
+    return {
+      data: EndpointUpdatedEventDataSerializer._toJsonObject(self.data),
+      type: self.type,
+    };
+  },
+};

node_modules/svix/src/models/endpointUpdatedEventData.ts

@@ -0,0 +1,33 @@
+// this file is @generated
+
+/** Sent when an endpoint is created, updated, or deleted */
+export interface EndpointUpdatedEventData {
+  /** The Application's ID. */
+  appId: string;
+  /** The Application's UID. */
+  appUid?: string | null;
+  /** The Endpoint's ID. */
+  endpointId: string;
+  /** The Endpoint's UID. */
+  endpointUid?: string | null;
+}
+
+export const EndpointUpdatedEventDataSerializer = {
+  _fromJsonObject(object: any): EndpointUpdatedEventData {
+    return {
+      appId: object["appId"],
+      appUid: object["appUid"],
+      endpointId: object["endpointId"],
+      endpointUid: object["endpointUid"],
+    };
+  },
+
+  _toJsonObject(self: EndpointUpdatedEventData): any {
+    return {
+      appId: self.appId,
+      appUid: self.appUid,
+      endpointId: self.endpointId,
+      endpointUid: self.endpointUid,
+    };
+  },
+};

node_modules/svix/src/models/environmentIn.ts

@@ -0,0 +1,35 @@
+// this file is @generated
+import { type ConnectorIn, ConnectorInSerializer } from "./connectorIn";
+import { type EventTypeIn, EventTypeInSerializer } from "./eventTypeIn";
+
+export interface EnvironmentIn {
+  connectors?: ConnectorIn[] | null;
+  eventTypes?: EventTypeIn[] | null;
+  settings?: any | null;
+}
+
+export const EnvironmentInSerializer = {
+  _fromJsonObject(object: any): EnvironmentIn {
+    return {
+      connectors: object["connectors"]?.map((item: ConnectorIn) =>
+        ConnectorInSerializer._fromJsonObject(item)
+      ),
+      eventTypes: object["eventTypes"]?.map((item: EventTypeIn) =>
+        EventTypeInSerializer._fromJsonObject(item)
+      ),
+      settings: object["settings"],
+    };
+  },
+
+  _toJsonObject(self: EnvironmentIn): any {
+    return {
+      connectors: self.connectors?.map((item) =>
+        ConnectorInSerializer._toJsonObject(item)
+      ),
+      eventTypes: self.eventTypes?.map((item) =>
+        EventTypeInSerializer._toJsonObject(item)
+      ),
+      settings: self.settings,
+    };
+  },
+};

node_modules/svix/src/models/environmentOut.ts

@@ -0,0 +1,41 @@
+// this file is @generated
+import { type ConnectorOut, ConnectorOutSerializer } from "./connectorOut";
+import { type EventTypeOut, EventTypeOutSerializer } from "./eventTypeOut";
+
+export interface EnvironmentOut {
+  connectors: ConnectorOut[];
+  createdAt: Date;
+  eventTypes: EventTypeOut[];
+  settings: any | null;
+  version?: number;
+}
+
+export const EnvironmentOutSerializer = {
+  _fromJsonObject(object: any): EnvironmentOut {
+    return {
+      connectors: object["connectors"].map((item: ConnectorOut) =>
+        ConnectorOutSerializer._fromJsonObject(item)
+      ),
+      createdAt: new Date(object["createdAt"]),
+      eventTypes: object["eventTypes"].map((item: EventTypeOut) =>
+        EventTypeOutSerializer._fromJsonObject(item)
+      ),
+      settings: object["settings"],
+      version: object["version"],
+    };
+  },
+
+  _toJsonObject(self: EnvironmentOut): any {
+    return {
+      connectors: self.connectors.map((item) =>
+        ConnectorOutSerializer._toJsonObject(item)
+      ),
+      createdAt: self.createdAt,
+      eventTypes: self.eventTypes.map((item) =>
+        EventTypeOutSerializer._toJsonObject(item)
+      ),
+      settings: self.settings,
+      version: self.version,
+    };
+  },
+};

node_modules/svix/src/models/eventExampleIn.ts

@@ -0,0 +1,28 @@
+// this file is @generated
+
+export interface EventExampleIn {
+  /** The event type's name */
+  eventType: string;
+  /**
+   * If the event type schema contains an array of examples, chooses which one to send.
+   *
+   * Defaults to the first example. Ignored if the schema doesn't contain an array of examples.
+   */
+  exampleIndex?: number;
+}
+
+export const EventExampleInSerializer = {
+  _fromJsonObject(object: any): EventExampleIn {
+    return {
+      eventType: object["eventType"],
+      exampleIndex: object["exampleIndex"],
+    };
+  },
+
+  _toJsonObject(self: EventExampleIn): any {
+    return {
+      eventType: self.eventType,
+      exampleIndex: self.exampleIndex,
+    };
+  },
+};

node_modules/svix/src/models/eventIn.ts

@@ -0,0 +1,23 @@
+// this file is @generated
+
+export interface EventIn {
+  /** The event type's name */
+  eventType: string;
+  payload: string;
+}
+
+export const EventInSerializer = {
+  _fromJsonObject(object: any): EventIn {
+    return {
+      eventType: object["eventType"],
+      payload: object["payload"],
+    };
+  },
+
+  _toJsonObject(self: EventIn): any {
+    return {
+      eventType: self.eventType,
+      payload: self.payload,
+    };
+  },
+};

node_modules/svix/src/models/eventOut.ts

@@ -0,0 +1,26 @@
+// this file is @generated
+
+export interface EventOut {
+  /** The event type's name */
+  eventType: string;
+  payload: string;
+  timestamp: Date;
+}
+
+export const EventOutSerializer = {
+  _fromJsonObject(object: any): EventOut {
+    return {
+      eventType: object["eventType"],
+      payload: object["payload"],
+      timestamp: new Date(object["timestamp"]),
+    };
+  },
+
+  _toJsonObject(self: EventOut): any {
+    return {
+      eventType: self.eventType,
+      payload: self.payload,
+      timestamp: self.timestamp,
+    };
+  },
+};

node_modules/svix/src/models/eventStreamOut.ts

@@ -0,0 +1,28 @@
+// this file is @generated
+import { type EventOut, EventOutSerializer } from "./eventOut";
+
+export interface EventStreamOut {
+  data: EventOut[];
+  done: boolean;
+  iterator: string;
+}
+
+export const EventStreamOutSerializer = {
+  _fromJsonObject(object: any): EventStreamOut {
+    return {
+      data: object["data"].map((item: EventOut) =>
+        EventOutSerializer._fromJsonObject(item)
+      ),
+      done: object["done"],
+      iterator: object["iterator"],
+    };
+  },
+
+  _toJsonObject(self: EventStreamOut): any {
+    return {
+      data: self.data.map((item) => EventOutSerializer._toJsonObject(item)),
+      done: self.done,
+      iterator: self.iterator,
+    };
+  },
+};

node_modules/svix/src/models/eventTypeFromOpenApi.ts

@@ -0,0 +1,44 @@
+// this file is @generated
+
+export interface EventTypeFromOpenApi {
+  deprecated: boolean;
+  description: string;
+  /**
+   * Deprecated, use `featureFlags` instead.
+   *
+   * @deprecated
+   */
+  featureFlag?: string | null;
+  featureFlags?: string[] | null;
+  /** The event type group's name */
+  groupName?: string | null;
+  /** The event type's name */
+  name: string;
+  schemas?: any | null;
+}
+
+export const EventTypeFromOpenApiSerializer = {
+  _fromJsonObject(object: any): EventTypeFromOpenApi {
+    return {
+      deprecated: object["deprecated"],
+      description: object["description"],
+      featureFlag: object["featureFlag"],
+      featureFlags: object["featureFlags"],
+      groupName: object["groupName"],
+      name: object["name"],
+      schemas: object["schemas"],
+    };
+  },
+
+  _toJsonObject(self: EventTypeFromOpenApi): any {
+    return {
+      deprecated: self.deprecated,
+      description: self.description,
+      featureFlag: self.featureFlag,
+      featureFlags: self.featureFlags,
+      groupName: self.groupName,
+      name: self.name,
+      schemas: self.schemas,
+    };
+  },
+};

node_modules/svix/src/models/eventTypeImportOpenApiIn.ts

@@ -0,0 +1,37 @@
+// this file is @generated
+
+/**
+ * Import a list of event types from webhooks defined in an OpenAPI spec.
+ *
+ * The OpenAPI spec can be specified as either `spec` given the spec as a JSON object, or as `specRaw` (a `string`) which will be parsed as YAML or JSON by the server. Sending neither or both is invalid, resulting in a `400` **Bad Request**.
+ */
+export interface EventTypeImportOpenApiIn {
+  /** If `true`, return the event types that would be modified without actually modifying them. */
+  dryRun?: boolean;
+  /** If `true`, all existing event types that are not in the spec will be archived. */
+  replaceAll?: boolean;
+  /** A pre-parsed JSON spec. */
+  spec?: any | null;
+  /** A string, parsed by the server as YAML or JSON. */
+  specRaw?: string | null;
+}
+
+export const EventTypeImportOpenApiInSerializer = {
+  _fromJsonObject(object: any): EventTypeImportOpenApiIn {
+    return {
+      dryRun: object["dryRun"],
+      replaceAll: object["replaceAll"],
+      spec: object["spec"],
+      specRaw: object["specRaw"],
+    };
+  },
+
+  _toJsonObject(self: EventTypeImportOpenApiIn): any {
+    return {
+      dryRun: self.dryRun,
+      replaceAll: self.replaceAll,
+      spec: self.spec,
+      specRaw: self.specRaw,
+    };
+  },
+};

node_modules/svix/src/models/eventTypeImportOpenApiOut.ts

@@ -0,0 +1,23 @@
+// this file is @generated
+import {
+  type EventTypeImportOpenApiOutData,
+  EventTypeImportOpenApiOutDataSerializer,
+} from "./eventTypeImportOpenApiOutData";
+
+export interface EventTypeImportOpenApiOut {
+  data: EventTypeImportOpenApiOutData;
+}
+
+export const EventTypeImportOpenApiOutSerializer = {
+  _fromJsonObject(object: any): EventTypeImportOpenApiOut {
+    return {
+      data: EventTypeImportOpenApiOutDataSerializer._fromJsonObject(object["data"]),
+    };
+  },
+
+  _toJsonObject(self: EventTypeImportOpenApiOut): any {
+    return {
+      data: EventTypeImportOpenApiOutDataSerializer._toJsonObject(self.data),
+    };
+  },
+};

node_modules/svix/src/models/eventTypeImportOpenApiOutData.ts

@@ -0,0 +1,30 @@
+// this file is @generated
+import {
+  type EventTypeFromOpenApi,
+  EventTypeFromOpenApiSerializer,
+} from "./eventTypeFromOpenApi";
+
+export interface EventTypeImportOpenApiOutData {
+  modified: string[];
+  toModify?: EventTypeFromOpenApi[] | null;
+}
+
+export const EventTypeImportOpenApiOutDataSerializer = {
+  _fromJsonObject(object: any): EventTypeImportOpenApiOutData {
+    return {
+      modified: object["modified"],
+      toModify: object["to_modify"]?.map((item: EventTypeFromOpenApi) =>
+        EventTypeFromOpenApiSerializer._fromJsonObject(item)
+      ),
+    };
+  },
+
+  _toJsonObject(self: EventTypeImportOpenApiOutData): any {
+    return {
+      modified: self.modified,
+      to_modify: self.toModify?.map((item) =>
+        EventTypeFromOpenApiSerializer._toJsonObject(item)
+      ),
+    };
+  },
+};

node_modules/svix/src/models/eventTypeIn.ts

@@ -0,0 +1,48 @@
+// this file is @generated
+
+export interface EventTypeIn {
+  archived?: boolean;
+  deprecated?: boolean;
+  description: string;
+  /**
+   * Deprecated, use `featureFlags` instead.
+   *
+   * @deprecated
+   */
+  featureFlag?: string | null;
+  featureFlags?: string[] | null;
+  /** The event type group's name */
+  groupName?: string | null;
+  /** The event type's name */
+  name: string;
+  /** The schema for the event type for a specific version as a JSON schema. */
+  schemas?: any | null;
+}
+
+export const EventTypeInSerializer = {
+  _fromJsonObject(object: any): EventTypeIn {
+    return {
+      archived: object["archived"],
+      deprecated: object["deprecated"],
+      description: object["description"],
+      featureFlag: object["featureFlag"],
+      featureFlags: object["featureFlags"],
+      groupName: object["groupName"],
+      name: object["name"],
+      schemas: object["schemas"],
+    };
+  },
+
+  _toJsonObject(self: EventTypeIn): any {
+    return {
+      archived: self.archived,
+      deprecated: self.deprecated,
+      description: self.description,
+      featureFlag: self.featureFlag,
+      featureFlags: self.featureFlags,
+      groupName: self.groupName,
+      name: self.name,
+      schemas: self.schemas,
+    };
+  },
+};

node_modules/svix/src/models/eventTypeOut.ts

@@ -0,0 +1,49 @@
+// this file is @generated
+
+export interface EventTypeOut {
+  archived?: boolean;
+  createdAt: Date;
+  deprecated: boolean;
+  description: string;
+  featureFlag?: string | null;
+  featureFlags?: string[] | null;
+  /** The event type group's name */
+  groupName?: string | null;
+  /** The event type's name */
+  name: string;
+  /** The schema for the event type for a specific version as a JSON schema. */
+  schemas?: any | null;
+  updatedAt: Date;
+}
+
+export const EventTypeOutSerializer = {
+  _fromJsonObject(object: any): EventTypeOut {
+    return {
+      archived: object["archived"],
+      createdAt: new Date(object["createdAt"]),
+      deprecated: object["deprecated"],
+      description: object["description"],
+      featureFlag: object["featureFlag"],
+      featureFlags: object["featureFlags"],
+      groupName: object["groupName"],
+      name: object["name"],
+      schemas: object["schemas"],
+      updatedAt: new Date(object["updatedAt"]),
+    };
+  },
+
+  _toJsonObject(self: EventTypeOut): any {
+    return {
+      archived: self.archived,
+      createdAt: self.createdAt,
+      deprecated: self.deprecated,
+      description: self.description,
+      featureFlag: self.featureFlag,
+      featureFlags: self.featureFlags,
+      groupName: self.groupName,
+      name: self.name,
+      schemas: self.schemas,
+      updatedAt: self.updatedAt,
+    };
+  },
+};

node_modules/svix/src/models/eventTypePatch.ts

@@ -0,0 +1,43 @@
+// this file is @generated
+
+export interface EventTypePatch {
+  archived?: boolean;
+  deprecated?: boolean;
+  description?: string;
+  /**
+   * Deprecated, use `featureFlags` instead.
+   *
+   * @deprecated
+   */
+  featureFlag?: string | null;
+  featureFlags?: string[] | null;
+  /** The event type group's name */
+  groupName?: string | null;
+  schemas?: any | null;
+}
+
+export const EventTypePatchSerializer = {
+  _fromJsonObject(object: any): EventTypePatch {
+    return {
+      archived: object["archived"],
+      deprecated: object["deprecated"],
+      description: object["description"],
+      featureFlag: object["featureFlag"],
+      featureFlags: object["featureFlags"],
+      groupName: object["groupName"],
+      schemas: object["schemas"],
+    };
+  },
+
+  _toJsonObject(self: EventTypePatch): any {
+    return {
+      archived: self.archived,
+      deprecated: self.deprecated,
+      description: self.description,
+      featureFlag: self.featureFlag,
+      featureFlags: self.featureFlags,
+      groupName: self.groupName,
+      schemas: self.schemas,
+    };
+  },
+};

node_modules/svix/src/models/eventTypeUpdate.ts

@@ -0,0 +1,44 @@
+// this file is @generated
+
+export interface EventTypeUpdate {
+  archived?: boolean;
+  deprecated?: boolean;
+  description: string;
+  /**
+   * Deprecated, use `featureFlags` instead.
+   *
+   * @deprecated
+   */
+  featureFlag?: string | null;
+  featureFlags?: string[] | null;
+  /** The event type group's name */
+  groupName?: string | null;
+  /** The schema for the event type for a specific version as a JSON schema. */
+  schemas?: any | null;
+}
+
+export const EventTypeUpdateSerializer = {
+  _fromJsonObject(object: any): EventTypeUpdate {
+    return {
+      archived: object["archived"],
+      deprecated: object["deprecated"],
+      description: object["description"],
+      featureFlag: object["featureFlag"],
+      featureFlags: object["featureFlags"],
+      groupName: object["groupName"],
+      schemas: object["schemas"],
+    };
+  },
+
+  _toJsonObject(self: EventTypeUpdate): any {
+    return {
+      archived: self.archived,
+      deprecated: self.deprecated,
+      description: self.description,
+      featureFlag: self.featureFlag,
+      featureFlags: self.featureFlags,
+      groupName: self.groupName,
+      schemas: self.schemas,
+    };
+  },
+};

node_modules/svix/src/models/expungeAllContentsOut.ts

@@ -0,0 +1,37 @@
+// this file is @generated
+import {
+  type BackgroundTaskStatus,
+  BackgroundTaskStatusSerializer,
+} from "./backgroundTaskStatus";
+import {
+  type BackgroundTaskType,
+  BackgroundTaskTypeSerializer,
+} from "./backgroundTaskType";
+
+export interface ExpungeAllContentsOut {
+  /** The QueueBackgroundTask's ID. */
+  id: string;
+  status: BackgroundTaskStatus;
+  task: BackgroundTaskType;
+  updatedAt: Date;
+}
+
+export const ExpungeAllContentsOutSerializer = {
+  _fromJsonObject(object: any): ExpungeAllContentsOut {
+    return {
+      id: object["id"],
+      status: BackgroundTaskStatusSerializer._fromJsonObject(object["status"]),
+      task: BackgroundTaskTypeSerializer._fromJsonObject(object["task"]),
+      updatedAt: new Date(object["updatedAt"]),
+    };
+  },
+
+  _toJsonObject(self: ExpungeAllContentsOut): any {
+    return {
+      id: self.id,
+      status: BackgroundTaskStatusSerializer._toJsonObject(self.status),
+      task: BackgroundTaskTypeSerializer._toJsonObject(self.task),
+      updatedAt: self.updatedAt,
+    };
+  },
+};

node_modules/svix/src/models/githubConfig.ts

@@ -0,0 +1,19 @@
+// this file is @generated
+
+export interface GithubConfig {
+  secret?: string | null;
+}
+
+export const GithubConfigSerializer = {
+  _fromJsonObject(object: any): GithubConfig {
+    return {
+      secret: object["secret"],
+    };
+  },
+
+  _toJsonObject(self: GithubConfig): any {
+    return {
+      secret: self.secret,
+    };
+  },
+};

node_modules/svix/src/models/githubConfigOut.ts

@@ -0,0 +1,15 @@
+// this file is @generated
+
+// biome-ignore-all lint/suspicious/noEmptyInterface: backwards compat
+
+export interface GithubConfigOut {}
+
+export const GithubConfigOutSerializer = {
+  _fromJsonObject(_object: any): GithubConfigOut {
+    return {};
+  },
+
+  _toJsonObject(_self: GithubConfigOut): any {
+    return {};
+  },
+};

node_modules/svix/src/models/googleCloudStorageConfig.ts

@@ -0,0 +1,28 @@
+// this file is @generated
+
+/**
+ * Configuration for a Google Cloud Storage sink.
+ *
+ * Write stream events into the named bucket using the supplied Google Cloud credentials.
+ */
+export interface GoogleCloudStorageConfig {
+  bucket: string;
+  /** Google Cloud Credentials JSON Object as a string. */
+  credentials: string;
+}
+
+export const GoogleCloudStorageConfigSerializer = {
+  _fromJsonObject(object: any): GoogleCloudStorageConfig {
+    return {
+      bucket: object["bucket"],
+      credentials: object["credentials"],
+    };
+  },
+
+  _toJsonObject(self: GoogleCloudStorageConfig): any {
+    return {
+      bucket: self.bucket,
+      credentials: self.credentials,
+    };
+  },
+};

node_modules/svix/src/models/googleCloudStoragePatchConfig.ts

@@ -0,0 +1,22 @@
+// this file is @generated
+
+export interface GoogleCloudStoragePatchConfig {
+  bucket?: string;
+  credentials?: string;
+}
+
+export const GoogleCloudStoragePatchConfigSerializer = {
+  _fromJsonObject(object: any): GoogleCloudStoragePatchConfig {
+    return {
+      bucket: object["bucket"],
+      credentials: object["credentials"],
+    };
+  },
+
+  _toJsonObject(self: GoogleCloudStoragePatchConfig): any {
+    return {
+      bucket: self.bucket,
+      credentials: self.credentials,
+    };
+  },
+};

node_modules/svix/src/models/httpAttemptTimes.ts

@@ -0,0 +1,22 @@
+// this file is @generated
+
+export interface HttpAttemptTimes {
+  end: Date;
+  start: Date;
+}
+
+export const HttpAttemptTimesSerializer = {
+  _fromJsonObject(object: any): HttpAttemptTimes {
+    return {
+      end: new Date(object["end"]),
+      start: new Date(object["start"]),
+    };
+  },
+
+  _toJsonObject(self: HttpAttemptTimes): any {
+    return {
+      end: self.end,
+      start: self.start,
+    };
+  },
+};

node_modules/svix/src/models/httpPatchConfig.ts

@@ -0,0 +1,19 @@
+// this file is @generated
+
+export interface HttpPatchConfig {
+  url?: string;
+}
+
+export const HttpPatchConfigSerializer = {
+  _fromJsonObject(object: any): HttpPatchConfig {
+    return {
+      url: object["url"],
+    };
+  },
+
+  _toJsonObject(self: HttpPatchConfig): any {
+    return {
+      url: self.url,
+    };
+  },
+};

node_modules/svix/src/models/httpSinkHeadersPatchIn.ts

@@ -0,0 +1,19 @@
+// this file is @generated
+
+export interface HttpSinkHeadersPatchIn {
+  headers: { [key: string]: string };
+}
+
+export const HttpSinkHeadersPatchInSerializer = {
+  _fromJsonObject(object: any): HttpSinkHeadersPatchIn {
+    return {
+      headers: object["headers"],
+    };
+  },
+
+  _toJsonObject(self: HttpSinkHeadersPatchIn): any {
+    return {
+      headers: self.headers,
+    };
+  },
+};

node_modules/svix/src/models/hubspotConfig.ts

@@ -0,0 +1,19 @@
+// this file is @generated
+
+export interface HubspotConfig {
+  secret?: string | null;
+}
+
+export const HubspotConfigSerializer = {
+  _fromJsonObject(object: any): HubspotConfig {
+    return {
+      secret: object["secret"],
+    };
+  },
+
+  _toJsonObject(self: HubspotConfig): any {
+    return {
+      secret: self.secret,
+    };
+  },
+};

node_modules/svix/src/models/hubspotConfigOut.ts

@@ -0,0 +1,15 @@
+// this file is @generated
+
+// biome-ignore-all lint/suspicious/noEmptyInterface: backwards compat
+
+export interface HubspotConfigOut {}
+
+export const HubspotConfigOutSerializer = {
+  _fromJsonObject(_object: any): HubspotConfigOut {
+    return {};
+  },
+
+  _toJsonObject(_self: HubspotConfigOut): any {
+    return {};
+  },
+};

node_modules/svix/src/models/index.ts

@@ -0,0 +1,216 @@
+// this file is @generated
+export { AdobeSignConfig } from "./adobeSignConfig";
+export { AdobeSignConfigOut } from "./adobeSignConfigOut";
+export { AggregateEventTypesOut } from "./aggregateEventTypesOut";
+export { AirwallexConfig } from "./airwallexConfig";
+export { AirwallexConfigOut } from "./airwallexConfigOut";
+export { AmazonS3PatchConfig } from "./amazonS3PatchConfig";
+export { ApiTokenOut } from "./apiTokenOut";
+export { AppPortalAccessIn } from "./appPortalAccessIn";
+export { AppPortalAccessOut } from "./appPortalAccessOut";
+export { AppPortalCapability } from "./appPortalCapability";
+export { AppUsageStatsIn } from "./appUsageStatsIn";
+export { AppUsageStatsOut } from "./appUsageStatsOut";
+export { ApplicationIn } from "./applicationIn";
+export { ApplicationOut } from "./applicationOut";
+export { ApplicationPatch } from "./applicationPatch";
+export { ApplicationTokenExpireIn } from "./applicationTokenExpireIn";
+export { AzureBlobStorageConfig } from "./azureBlobStorageConfig";
+export { AzureBlobStoragePatchConfig } from "./azureBlobStoragePatchConfig";
+export { BackgroundTaskFinishedEvent } from "./backgroundTaskFinishedEvent";
+export { BackgroundTaskFinishedEvent2 } from "./backgroundTaskFinishedEvent2";
+export { BackgroundTaskOut } from "./backgroundTaskOut";
+export { BackgroundTaskStatus } from "./backgroundTaskStatus";
+export { BackgroundTaskType } from "./backgroundTaskType";
+export { BulkReplayIn } from "./bulkReplayIn";
+export { CheckbookConfig } from "./checkbookConfig";
+export { CheckbookConfigOut } from "./checkbookConfigOut";
+export { ConnectorIn } from "./connectorIn";
+export { ConnectorKind } from "./connectorKind";
+export { ConnectorOut } from "./connectorOut";
+export { ConnectorPatch } from "./connectorPatch";
+export { ConnectorProduct } from "./connectorProduct";
+export { ConnectorUpdate } from "./connectorUpdate";
+export { CreateStreamEventsIn } from "./createStreamEventsIn";
+export { CreateStreamEventsOut } from "./createStreamEventsOut";
+export { CronConfig } from "./cronConfig";
+export { DashboardAccessOut } from "./dashboardAccessOut";
+export { DocusignConfig } from "./docusignConfig";
+export { DocusignConfigOut } from "./docusignConfigOut";
+export { EasypostConfig } from "./easypostConfig";
+export { EasypostConfigOut } from "./easypostConfigOut";
+export { EmptyResponse } from "./emptyResponse";
+export { EndpointCreatedEvent } from "./endpointCreatedEvent";
+export { EndpointCreatedEventData } from "./endpointCreatedEventData";
+export { EndpointDeletedEvent } from "./endpointDeletedEvent";
+export { EndpointDeletedEventData } from "./endpointDeletedEventData";
+export { EndpointDisabledEvent } from "./endpointDisabledEvent";
+export { EndpointDisabledEventData } from "./endpointDisabledEventData";
+export { EndpointDisabledTrigger } from "./endpointDisabledTrigger";
+export { EndpointEnabledEvent } from "./endpointEnabledEvent";
+export { EndpointEnabledEventData } from "./endpointEnabledEventData";
+export { EndpointHeadersIn } from "./endpointHeadersIn";
+export { EndpointHeadersOut } from "./endpointHeadersOut";
+export { EndpointHeadersPatchIn } from "./endpointHeadersPatchIn";
+export { EndpointIn } from "./endpointIn";
+export { EndpointMessageOut } from "./endpointMessageOut";
+export { EndpointOut } from "./endpointOut";
+export { EndpointPatch } from "./endpointPatch";
+export { EndpointSecretOut } from "./endpointSecretOut";
+export { EndpointSecretRotateIn } from "./endpointSecretRotateIn";
+export { EndpointStats } from "./endpointStats";
+export { EndpointTransformationIn } from "./endpointTransformationIn";
+export { EndpointTransformationOut } from "./endpointTransformationOut";
+export { EndpointTransformationPatch } from "./endpointTransformationPatch";
+export { EndpointUpdate } from "./endpointUpdate";
+export { EndpointUpdatedEvent } from "./endpointUpdatedEvent";
+export { EndpointUpdatedEventData } from "./endpointUpdatedEventData";
+export { EnvironmentIn } from "./environmentIn";
+export { EnvironmentOut } from "./environmentOut";
+export { EventExampleIn } from "./eventExampleIn";
+export { EventIn } from "./eventIn";
+export { EventOut } from "./eventOut";
+export { EventStreamOut } from "./eventStreamOut";
+export { EventTypeFromOpenApi } from "./eventTypeFromOpenApi";
+export { EventTypeImportOpenApiIn } from "./eventTypeImportOpenApiIn";
+export { EventTypeImportOpenApiOut } from "./eventTypeImportOpenApiOut";
+export { EventTypeImportOpenApiOutData } from "./eventTypeImportOpenApiOutData";
+export { EventTypeIn } from "./eventTypeIn";
+export { EventTypeOut } from "./eventTypeOut";
+export { EventTypePatch } from "./eventTypePatch";
+export { EventTypeUpdate } from "./eventTypeUpdate";
+export { ExpungeAllContentsOut } from "./expungeAllContentsOut";
+export { GithubConfig } from "./githubConfig";
+export { GithubConfigOut } from "./githubConfigOut";
+export { GoogleCloudStorageConfig } from "./googleCloudStorageConfig";
+export { GoogleCloudStoragePatchConfig } from "./googleCloudStoragePatchConfig";
+export { HttpAttemptTimes } from "./httpAttemptTimes";
+export { HttpPatchConfig } from "./httpPatchConfig";
+export { HttpSinkHeadersPatchIn } from "./httpSinkHeadersPatchIn";
+export { HubspotConfig } from "./hubspotConfig";
+export { HubspotConfigOut } from "./hubspotConfigOut";
+export { IngestEndpointDisabledEvent } from "./ingestEndpointDisabledEvent";
+export { IngestEndpointDisabledEventData } from "./ingestEndpointDisabledEventData";
+export { IngestEndpointHeadersIn } from "./ingestEndpointHeadersIn";
+export { IngestEndpointHeadersOut } from "./ingestEndpointHeadersOut";
+export { IngestEndpointIn } from "./ingestEndpointIn";
+export { IngestEndpointOut } from "./ingestEndpointOut";
+export { IngestEndpointSecretIn } from "./ingestEndpointSecretIn";
+export { IngestEndpointSecretOut } from "./ingestEndpointSecretOut";
+export { IngestEndpointTransformationOut } from "./ingestEndpointTransformationOut";
+export { IngestEndpointTransformationPatch } from "./ingestEndpointTransformationPatch";
+export { IngestEndpointUpdate } from "./ingestEndpointUpdate";
+export { IngestMessageAttemptExhaustedEvent } from "./ingestMessageAttemptExhaustedEvent";
+export { IngestMessageAttemptExhaustedEventData } from "./ingestMessageAttemptExhaustedEventData";
+export { IngestMessageAttemptFailingEvent } from "./ingestMessageAttemptFailingEvent";
+export { IngestMessageAttemptFailingEventData } from "./ingestMessageAttemptFailingEventData";
+export { IngestMessageAttemptRecoveredEvent } from "./ingestMessageAttemptRecoveredEvent";
+export { IngestMessageAttemptRecoveredEventData } from "./ingestMessageAttemptRecoveredEventData";
+export { IngestSourceConsumerPortalAccessIn } from "./ingestSourceConsumerPortalAccessIn";
+export { IngestSourceIn } from "./ingestSourceIn";
+export { IngestSourceOut } from "./ingestSourceOut";
+export { IntegrationIn } from "./integrationIn";
+export { IntegrationKeyOut } from "./integrationKeyOut";
+export { IntegrationOut } from "./integrationOut";
+export { IntegrationUpdate } from "./integrationUpdate";
+export { ListResponseApplicationOut } from "./listResponseApplicationOut";
+export { ListResponseBackgroundTaskOut } from "./listResponseBackgroundTaskOut";
+export { ListResponseConnectorOut } from "./listResponseConnectorOut";
+export { ListResponseEndpointMessageOut } from "./listResponseEndpointMessageOut";
+export { ListResponseEndpointOut } from "./listResponseEndpointOut";
+export { ListResponseEventTypeOut } from "./listResponseEventTypeOut";
+export { ListResponseIngestEndpointOut } from "./listResponseIngestEndpointOut";
+export { ListResponseIngestSourceOut } from "./listResponseIngestSourceOut";
+export { ListResponseIntegrationOut } from "./listResponseIntegrationOut";
+export { ListResponseMessageAttemptOut } from "./listResponseMessageAttemptOut";
+export { ListResponseMessageEndpointOut } from "./listResponseMessageEndpointOut";
+export { ListResponseMessageOut } from "./listResponseMessageOut";
+export { ListResponseOperationalWebhookEndpointOut } from "./listResponseOperationalWebhookEndpointOut";
+export { ListResponseStreamEventTypeOut } from "./listResponseStreamEventTypeOut";
+export { ListResponseStreamOut } from "./listResponseStreamOut";
+export { ListResponseStreamSinkOut } from "./listResponseStreamSinkOut";
+export { MessageAttemptExhaustedEvent } from "./messageAttemptExhaustedEvent";
+export { MessageAttemptExhaustedEventData } from "./messageAttemptExhaustedEventData";
+export { MessageAttemptFailedData } from "./messageAttemptFailedData";
+export { MessageAttemptFailingEvent } from "./messageAttemptFailingEvent";
+export { MessageAttemptFailingEventData } from "./messageAttemptFailingEventData";
+export { MessageAttemptLog } from "./messageAttemptLog";
+export { MessageAttemptLogEvent } from "./messageAttemptLogEvent";
+export { MessageAttemptOut } from "./messageAttemptOut";
+export { MessageAttemptRecoveredEvent } from "./messageAttemptRecoveredEvent";
+export { MessageAttemptRecoveredEventData } from "./messageAttemptRecoveredEventData";
+export { MessageAttemptTriggerType } from "./messageAttemptTriggerType";
+export { MessageEndpointOut } from "./messageEndpointOut";
+export { MessageIn } from "./messageIn";
+export { MessageOut } from "./messageOut";
+export { MessagePrecheckIn } from "./messagePrecheckIn";
+export { MessagePrecheckOut } from "./messagePrecheckOut";
+export { MessageStatus } from "./messageStatus";
+export { MessageStatusText } from "./messageStatusText";
+export { MetaConfig } from "./metaConfig";
+export { MetaConfigOut } from "./metaConfigOut";
+export { OperationalWebhookEndpointHeadersIn } from "./operationalWebhookEndpointHeadersIn";
+export { OperationalWebhookEndpointHeadersOut } from "./operationalWebhookEndpointHeadersOut";
+export { OperationalWebhookEndpointIn } from "./operationalWebhookEndpointIn";
+export { OperationalWebhookEndpointOut } from "./operationalWebhookEndpointOut";
+export { OperationalWebhookEndpointSecretIn } from "./operationalWebhookEndpointSecretIn";
+export { OperationalWebhookEndpointSecretOut } from "./operationalWebhookEndpointSecretOut";
+export { OperationalWebhookEndpointUpdate } from "./operationalWebhookEndpointUpdate";
+export { Ordering } from "./ordering";
+export { OrumIoConfig } from "./orumIoConfig";
+export { OrumIoConfigOut } from "./orumIoConfigOut";
+export { OtelTracingPatchConfig } from "./otelTracingPatchConfig";
+export { PandaDocConfig } from "./pandaDocConfig";
+export { PandaDocConfigOut } from "./pandaDocConfigOut";
+export { PollingEndpointConsumerSeekIn } from "./pollingEndpointConsumerSeekIn";
+export { PollingEndpointConsumerSeekOut } from "./pollingEndpointConsumerSeekOut";
+export { PollingEndpointMessageOut } from "./pollingEndpointMessageOut";
+export { PollingEndpointOut } from "./pollingEndpointOut";
+export { PortIoConfig } from "./portIoConfig";
+export { PortIoConfigOut } from "./portIoConfigOut";
+export { RecoverIn } from "./recoverIn";
+export { RecoverOut } from "./recoverOut";
+export { ReplayIn } from "./replayIn";
+export { ReplayOut } from "./replayOut";
+export { RotatePollerTokenIn } from "./rotatePollerTokenIn";
+export { RotateTokenOut } from "./rotateTokenOut";
+export { RutterConfig } from "./rutterConfig";
+export { RutterConfigOut } from "./rutterConfigOut";
+export { S3Config } from "./s3Config";
+export { SegmentConfig } from "./segmentConfig";
+export { SegmentConfigOut } from "./segmentConfigOut";
+export { ShopifyConfig } from "./shopifyConfig";
+export { ShopifyConfigOut } from "./shopifyConfigOut";
+export { SinkHttpConfig } from "./sinkHttpConfig";
+export { SinkOtelV1Config } from "./sinkOtelV1Config";
+export { SinkSecretOut } from "./sinkSecretOut";
+export { SinkStatus } from "./sinkStatus";
+export { SinkStatusIn } from "./sinkStatusIn";
+export { SinkTransformIn } from "./sinkTransformIn";
+export { SinkTransformationOut } from "./sinkTransformationOut";
+export { SlackConfig } from "./slackConfig";
+export { SlackConfigOut } from "./slackConfigOut";
+export { StatusCodeClass } from "./statusCodeClass";
+export { StreamEventTypeIn } from "./streamEventTypeIn";
+export { StreamEventTypeOut } from "./streamEventTypeOut";
+export { StreamEventTypePatch } from "./streamEventTypePatch";
+export { StreamIn } from "./streamIn";
+export { StreamOut } from "./streamOut";
+export { StreamPatch } from "./streamPatch";
+export { StreamPortalAccessIn } from "./streamPortalAccessIn";
+export { StreamSinkIn } from "./streamSinkIn";
+export { StreamSinkOut } from "./streamSinkOut";
+export { StreamSinkPatch } from "./streamSinkPatch";
+export { StreamTokenExpireIn } from "./streamTokenExpireIn";
+export { StripeConfig } from "./stripeConfig";
+export { StripeConfigOut } from "./stripeConfigOut";
+export { SvixConfig } from "./svixConfig";
+export { SvixConfigOut } from "./svixConfigOut";
+export { TelnyxConfig } from "./telnyxConfig";
+export { TelnyxConfigOut } from "./telnyxConfigOut";
+export { VapiConfig } from "./vapiConfig";
+export { VapiConfigOut } from "./vapiConfigOut";
+export { VeriffConfig } from "./veriffConfig";
+export { VeriffConfigOut } from "./veriffConfigOut";
+export { ZoomConfig } from "./zoomConfig";
+export { ZoomConfigOut } from "./zoomConfigOut";

node_modules/svix/src/models/ingestEndpointDisabledEvent.ts

@@ -0,0 +1,27 @@
+// this file is @generated
+import {
+  type IngestEndpointDisabledEventData,
+  IngestEndpointDisabledEventDataSerializer,
+} from "./ingestEndpointDisabledEventData";
+
+/** Sent when an ingest endpoint has been automatically disabled after continuous failures, or manually via an API call. */
+export interface IngestEndpointDisabledEvent {
+  data: IngestEndpointDisabledEventData;
+  type: string;
+}
+
+export const IngestEndpointDisabledEventSerializer = {
+  _fromJsonObject(object: any): IngestEndpointDisabledEvent {
+    return {
+      data: IngestEndpointDisabledEventDataSerializer._fromJsonObject(object["data"]),
+      type: object["type"],
+    };
+  },
+
+  _toJsonObject(self: IngestEndpointDisabledEvent): any {
+    return {
+      data: IngestEndpointDisabledEventDataSerializer._toJsonObject(self.data),
+      type: self.type,
+    };
+  },
+};

node_modules/svix/src/models/ingestEndpointDisabledEventData.ts

@@ -0,0 +1,45 @@
+// this file is @generated
+import {
+  type EndpointDisabledTrigger,
+  EndpointDisabledTriggerSerializer,
+} from "./endpointDisabledTrigger";
+
+/** Sent when an ingest endpoint has been automatically disabled after continuous failures, or manually via an API call. */
+export interface IngestEndpointDisabledEventData {
+  /** The Endpoint's ID. */
+  endpointId: string;
+  /** The Endpoint's UID. */
+  endpointUid?: string | null;
+  failSince?: Date | null;
+  /** The Source's ID. */
+  sourceId: string;
+  trigger?: EndpointDisabledTrigger;
+}
+
+export const IngestEndpointDisabledEventDataSerializer = {
+  _fromJsonObject(object: any): IngestEndpointDisabledEventData {
+    return {
+      endpointId: object["endpointId"],
+      endpointUid: object["endpointUid"],
+      failSince: object["failSince"] ? new Date(object["failSince"]) : null,
+      sourceId: object["sourceId"],
+      trigger:
+        object["trigger"] != null
+          ? EndpointDisabledTriggerSerializer._fromJsonObject(object["trigger"])
+          : undefined,
+    };
+  },
+
+  _toJsonObject(self: IngestEndpointDisabledEventData): any {
+    return {
+      endpointId: self.endpointId,
+      endpointUid: self.endpointUid,
+      failSince: self.failSince,
+      sourceId: self.sourceId,
+      trigger:
+        self.trigger != null
+          ? EndpointDisabledTriggerSerializer._toJsonObject(self.trigger)
+          : undefined,
+    };
+  },
+};

node_modules/svix/src/models/ingestEndpointHeadersIn.ts

@@ -0,0 +1,19 @@
+// this file is @generated
+
+export interface IngestEndpointHeadersIn {
+  headers: { [key: string]: string };
+}
+
+export const IngestEndpointHeadersInSerializer = {
+  _fromJsonObject(object: any): IngestEndpointHeadersIn {
+    return {
+      headers: object["headers"],
+    };
+  },
+
+  _toJsonObject(self: IngestEndpointHeadersIn): any {
+    return {
+      headers: self.headers,
+    };
+  },
+};

node_modules/svix/src/models/ingestEndpointHeadersOut.ts

@@ -0,0 +1,22 @@
+// this file is @generated
+
+export interface IngestEndpointHeadersOut {
+  headers: { [key: string]: string };
+  sensitive: string[];
+}
+
+export const IngestEndpointHeadersOutSerializer = {
+  _fromJsonObject(object: any): IngestEndpointHeadersOut {
+    return {
+      headers: object["headers"],
+      sensitive: object["sensitive"],
+    };
+  },
+
+  _toJsonObject(self: IngestEndpointHeadersOut): any {
+    return {
+      headers: self.headers,
+      sensitive: self.sensitive,
+    };
+  },
+};

node_modules/svix/src/models/ingestEndpointIn.ts

@@ -0,0 +1,44 @@
+// this file is @generated
+
+export interface IngestEndpointIn {
+  description?: string;
+  disabled?: boolean;
+  metadata?: { [key: string]: string };
+  rateLimit?: number | null;
+  /**
+   * The endpoint's verification secret.
+   *
+   * Format: `base64` encoded random bytes optionally prefixed with `whsec_`.
+   * It is recommended to not set this and let the server generate the secret.
+   */
+  secret?: string | null;
+  /** Optional unique identifier for the endpoint. */
+  uid?: string | null;
+  url: string;
+}
+
+export const IngestEndpointInSerializer = {
+  _fromJsonObject(object: any): IngestEndpointIn {
+    return {
+      description: object["description"],
+      disabled: object["disabled"],
+      metadata: object["metadata"],
+      rateLimit: object["rateLimit"],
+      secret: object["secret"],
+      uid: object["uid"],
+      url: object["url"],
+    };
+  },
+
+  _toJsonObject(self: IngestEndpointIn): any {
+    return {
+      description: self.description,
+      disabled: self.disabled,
+      metadata: self.metadata,
+      rateLimit: self.rateLimit,
+      secret: self.secret,
+      uid: self.uid,
+      url: self.url,
+    };
+  },
+};

node_modules/svix/src/models/ingestEndpointOut.ts

@@ -0,0 +1,46 @@
+// this file is @generated
+
+export interface IngestEndpointOut {
+  createdAt: Date;
+  /** An example endpoint name. */
+  description: string;
+  disabled?: boolean;
+  /** The Endpoint's ID. */
+  id: string;
+  metadata: { [key: string]: string };
+  rateLimit?: number | null;
+  /** Optional unique identifier for the endpoint. */
+  uid?: string | null;
+  updatedAt: Date;
+  url: string;
+}
+
+export const IngestEndpointOutSerializer = {
+  _fromJsonObject(object: any): IngestEndpointOut {
+    return {
+      createdAt: new Date(object["createdAt"]),
+      description: object["description"],
+      disabled: object["disabled"],
+      id: object["id"],
+      metadata: object["metadata"],
+      rateLimit: object["rateLimit"],
+      uid: object["uid"],
+      updatedAt: new Date(object["updatedAt"]),
+      url: object["url"],
+    };
+  },
+
+  _toJsonObject(self: IngestEndpointOut): any {
+    return {
+      createdAt: self.createdAt,
+      description: self.description,
+      disabled: self.disabled,
+      id: self.id,
+      metadata: self.metadata,
+      rateLimit: self.rateLimit,
+      uid: self.uid,
+      updatedAt: self.updatedAt,
+      url: self.url,
+    };
+  },
+};

node_modules/svix/src/models/ingestEndpointSecretIn.ts

@@ -0,0 +1,25 @@
+// this file is @generated
+
+export interface IngestEndpointSecretIn {
+  /**
+   * The endpoint's verification secret.
+   *
+   * Format: `base64` encoded random bytes optionally prefixed with `whsec_`.
+   * It is recommended to not set this and let the server generate the secret.
+   */
+  key?: string | null;
+}
+
+export const IngestEndpointSecretInSerializer = {
+  _fromJsonObject(object: any): IngestEndpointSecretIn {
+    return {
+      key: object["key"],
+    };
+  },
+
+  _toJsonObject(self: IngestEndpointSecretIn): any {
+    return {
+      key: self.key,
+    };
+  },
+};

node_modules/svix/src/models/ingestEndpointSecretOut.ts

@@ -0,0 +1,25 @@
+// this file is @generated
+
+export interface IngestEndpointSecretOut {
+  /**
+   * The endpoint's verification secret.
+   *
+   * Format: `base64` encoded random bytes optionally prefixed with `whsec_`.
+   * It is recommended to not set this and let the server generate the secret.
+   */
+  key: string;
+}
+
+export const IngestEndpointSecretOutSerializer = {
+  _fromJsonObject(object: any): IngestEndpointSecretOut {
+    return {
+      key: object["key"],
+    };
+  },
+
+  _toJsonObject(self: IngestEndpointSecretOut): any {
+    return {
+      key: self.key,
+    };
+  },
+};

node_modules/svix/src/models/ingestEndpointTransformationOut.ts

@@ -0,0 +1,22 @@
+// this file is @generated
+
+export interface IngestEndpointTransformationOut {
+  code?: string | null;
+  enabled?: boolean;
+}
+
+export const IngestEndpointTransformationOutSerializer = {
+  _fromJsonObject(object: any): IngestEndpointTransformationOut {
+    return {
+      code: object["code"],
+      enabled: object["enabled"],
+    };
+  },
+
+  _toJsonObject(self: IngestEndpointTransformationOut): any {
+    return {
+      code: self.code,
+      enabled: self.enabled,
+    };
+  },
+};