openai 7.18.0 → 7.20.0

package/src/resources/webhooks/webhooks.ts

@@ -4,7 +4,352 @@ import { APIResource } from '../../core/resource';
 import { buildHeaders, HeadersLike } from '../../internal/headers';
 import { verifyWebhookSignature, webhookSignatureRequiresSigning } from '../../lib/webhook-signature';
 
+import * as EventTypesAPI from './event-types';
+import { EventTypes } from './event-types';
+import { APIPromise } from '../../core/api-promise';
+import { CursorPage, type CursorPageParams, PagePromise } from '../../core/pagination';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+// Recognizable options across SDK runtime versions. Keep this independent of
+// private RequestOptions fields so older handwritten runtimes still compile.
+const normalizeRequestOptionsForQueryKeys = new Set([
+  'method',
+  'path',
+  'query',
+  'body',
+  'headers',
+  'maxRetries',
+  'stream',
+  'timeout',
+  'httpAgent',
+  'fetchOptions',
+  'signal',
+  'idempotencyKey',
+  'defaultBaseURL',
+  '__metadata',
+  '__binaryRequest',
+  '__binaryResponse',
+  '__streamClass',
+  '__security',
+  '__synthesizeEventData',
+]);
+
+function normalizeRequestOptionsForQuery(
+  value: unknown,
+  queryKeys: ReadonlyArray<string>,
+  options: RequestOptions | undefined,
+):
+  | ({
+      [K in 'headers' | 'maxRetries' | 'timeout' | 'signal' | 'idempotencyKey' | 'query']?: RequestOptions[K];
+    } & {
+      [
+        K in
+          | 'method'
+          | 'path'
+          | 'body'
+          | 'stream'
+          | 'httpAgent'
+          | 'fetchOptions'
+          | 'defaultBaseURL'
+          | '__metadata'
+          | '__binaryRequest'
+          | '__binaryResponse'
+          | '__streamClass'
+          | '__security'
+          | '__synthesizeEventData'
+      ]?: never;
+    })
+  | undefined {
+  if (typeof value !== 'object' || value === null) return undefined;
+  // Optional never fields can still be explicitly undefined unless consumers
+  // enable exactOptionalPropertyTypes. Snapshot data without invoking getters.
+  const entries = Object.entries(Object.getOwnPropertyDescriptors(value)).filter(
+    ([, descriptor]) => descriptor.enumerable && (!('value' in descriptor) || descriptor.value !== undefined),
+  );
+  const keys = entries.map(([key]) => key);
+  const requestOnly = keys.some(
+    (key) => normalizeRequestOptionsForQueryKeys.has(key) && !queryKeys.includes(key),
+  );
+  if (!requestOnly) return undefined;
+  // Declared query fields, including stream, must use the query argument.
+  // Mixing them with request-only options is ambiguous and could change the return type.
+  if (
+    options !== undefined ||
+    keys.some((key) => !normalizeRequestOptionsForQueryKeys.has(key) || queryKeys.includes(key))
+  ) {
+    throw new TypeError('Query parameters and request options must be passed as separate arguments.');
+  }
+  // The query position must not gain authority to change the request destination
+  // or transport. Those overrides require the explicit request options argument.
+  if (
+    keys.some(
+      (key) => !['headers', 'maxRetries', 'timeout', 'signal', 'idempotencyKey', 'query'].includes(key),
+    )
+  ) {
+    throw new TypeError('Pass transport overrides in the explicit request options argument.');
+  }
+  // Copy only the validated fields. Spreading value would reintroduce undefined
+  // transport overrides, and deleting them would mutate the caller's object.
+  return Object.fromEntries(
+    entries.map(([key, descriptor]) => {
+      if ('value' in descriptor) return [key, descriptor.value];
+      return [key, descriptor.get ? Reflect.apply(descriptor.get, value, []) : undefined];
+    }),
+  ) as {
+    [K in 'headers' | 'maxRetries' | 'timeout' | 'signal' | 'idempotencyKey' | 'query']?: RequestOptions[K];
+  } & {
+    [
+      K in
+        | 'method'
+        | 'path'
+        | 'body'
+        | 'stream'
+        | 'httpAgent'
+        | 'fetchOptions'
+        | 'defaultBaseURL'
+        | '__metadata'
+        | '__binaryRequest'
+        | '__binaryResponse'
+        | '__streamClass'
+        | '__security'
+        | '__synthesizeEventData'
+    ]?: never;
+  };
+}
+
 export class Webhooks extends APIResource {
+  eventTypes: EventTypesAPI.EventTypes = new EventTypesAPI.EventTypes(this._client);
+
+  /**
+   * Creates a webhook endpoint for the authenticated project.
+   *
+   * @example
+   * ```ts
+   * const webhookEndpointWithSecret =
+   *   await client.webhooks.create({
+   *     event_types: ['batch.completed'],
+   *     name: 'x',
+   *     url: 'https://',
+   *   });
+   * ```
+   */
+  create(body: WebhookCreateParams, options?: RequestOptions): APIPromise<WebhookEndpointWithSecret> {
+    return this._client.post('/webhook_endpoints', { body, ...options, __security: { bearerAuth: true } });
+  }
+
+  /**
+   * Retrieves a webhook endpoint for the authenticated project.
+   *
+   * @example
+   * ```ts
+   * const webhookEndpoint = await client.webhooks.retrieve(
+   *   'whe_123',
+   * );
+   * ```
+   */
+  retrieve(webhookEndpointID: string, options?: RequestOptions): APIPromise<WebhookEndpoint> {
+    return this._client.get(path`/webhook_endpoints/${webhookEndpointID}`, {
+      ...options,
+      __security: { bearerAuth: true },
+    });
+  }
+
+  /**
+   * Updates a webhook endpoint for the authenticated project.
+   *
+   * @example
+   * ```ts
+   * const webhookEndpoint = await client.webhooks.update('whe_123');
+   * ```
+   */
+  update(
+    webhookEndpointID: string,
+    body: WebhookUpdateParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<WebhookEndpoint> {
+    return this._client.post(path`/webhook_endpoints/${webhookEndpointID}`, {
+      body,
+      ...options,
+      __security: { bearerAuth: true },
+    });
+  }
+
+  /**
+   * Returns webhook endpoints for the authenticated project in newest-first order.
+   *
+   * @example
+   * ```ts
+   * // Automatically fetches more pages as needed.
+   * for await (const webhookEndpoint of client.webhooks.list()) {
+   *   // ...
+   * }
+   * ```
+   */
+  list(
+    query?:
+      | (WebhookListParams &
+          (
+            | {
+                [
+                  K in
+                    | 'method'
+                    | 'path'
+                    | 'query'
+                    | 'body'
+                    | 'headers'
+                    | 'maxRetries'
+                    | 'stream'
+                    | 'timeout'
+                    | 'httpAgent'
+                    | 'fetchOptions'
+                    | 'signal'
+                    | 'idempotencyKey'
+                    | 'defaultBaseURL'
+                    | '__metadata'
+                    | '__binaryRequest'
+                    | '__binaryResponse'
+                    | '__streamClass'
+                    | '__security'
+                    | '__synthesizeEventData'
+                ]?: never;
+              }
+            | null
+            | undefined
+          ))
+      | null
+      | undefined,
+    options?: RequestOptions,
+  ): PagePromise<WebhookEndpointsPage, WebhookEndpoint>;
+  list(
+    options?: {
+      [K in 'headers' | 'maxRetries' | 'timeout' | 'signal' | 'idempotencyKey' | 'query']?: RequestOptions[K];
+    } & {
+      [
+        K in
+          | 'method'
+          | 'path'
+          | 'body'
+          | 'stream'
+          | 'httpAgent'
+          | 'fetchOptions'
+          | 'defaultBaseURL'
+          | '__metadata'
+          | '__binaryRequest'
+          | '__binaryResponse'
+          | '__streamClass'
+          | '__security'
+          | '__synthesizeEventData'
+      ]?: never;
+    },
+  ): PagePromise<WebhookEndpointsPage, WebhookEndpoint>;
+  list(
+    query:
+      | WebhookListParams
+      | ({
+          [
+            K in 'headers' | 'maxRetries' | 'timeout' | 'signal' | 'idempotencyKey' | 'query'
+          ]?: RequestOptions[K];
+        } & {
+          [
+            K in
+              | 'method'
+              | 'path'
+              | 'body'
+              | 'stream'
+              | 'httpAgent'
+              | 'fetchOptions'
+              | 'defaultBaseURL'
+              | '__metadata'
+              | '__binaryRequest'
+              | '__binaryResponse'
+              | '__streamClass'
+              | '__security'
+              | '__synthesizeEventData'
+          ]?: never;
+        })
+      | null
+      | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<WebhookEndpointsPage, WebhookEndpoint> {
+    const normalizeRequestOptionsForQueryOptions = normalizeRequestOptionsForQuery(
+      query,
+      ['after', 'limit'],
+      options,
+    );
+    if (normalizeRequestOptionsForQueryOptions !== undefined) {
+      options = normalizeRequestOptionsForQueryOptions;
+      query = {};
+    }
+    query = query as WebhookListParams | null | undefined;
+    return this._client.getAPIList('/webhook_endpoints', CursorPage<WebhookEndpoint>, {
+      query,
+      ...options,
+      __security: { bearerAuth: true },
+    });
+  }
+
+  /**
+   * Deletes a webhook endpoint for the authenticated project.
+   *
+   * @example
+   * ```ts
+   * const deletedWebhookEndpoint = await client.webhooks.delete(
+   *   'whe_123',
+   * );
+   * ```
+   */
+  delete(webhookEndpointID: string, options?: RequestOptions): APIPromise<DeletedWebhookEndpoint> {
+    return this._client.delete(path`/webhook_endpoints/${webhookEndpointID}`, {
+      ...options,
+      __security: { bearerAuth: true },
+    });
+  }
+
+  /**
+   * Rotates the signing secret for a webhook endpoint in the authenticated project.
+   *
+   * @example
+   * ```ts
+   * const webhookEndpointWithSecret =
+   *   await client.webhooks.rotateSecret('whe_123');
+   * ```
+   */
+  rotateSecret(
+    webhookEndpointID: string,
+    body: WebhookRotateSecretParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<WebhookEndpointWithSecret> {
+    return this._client.post(path`/webhook_endpoints/${webhookEndpointID}/rotate_secret`, {
+      body,
+      ...options,
+      __security: { bearerAuth: true },
+    });
+  }
+
+  /**
+   * Sends a sample event to a webhook endpoint for the authenticated project.
+   *
+   * @example
+   * ```ts
+   * const webhookEndpointTestResult =
+   *   await client.webhooks.test('whe_123', {
+   *     event_type: 'batch.completed',
+   *   });
+   * ```
+   */
+  test(
+    webhookEndpointID: string,
+    body: WebhookTestParams,
+    options?: RequestOptions,
+  ): APIPromise<WebhookEndpointTestResult> {
+    return this._client.post(path`/webhook_endpoints/${webhookEndpointID}/test`, {
+      body,
+      ...options,
+      __security: { bearerAuth: true },
+    });
+  }
+
   /**
    * Validates that the given payload was sent by OpenAI and parses the payload.
    */
@@ -80,6 +425,8 @@ export class Webhooks extends APIResource {
   }
 }
 
+export type WebhookEndpointsPage = CursorPage<WebhookEndpoint>;
+
 /**
  * Sent when a batch API request has been cancelled.
  */
@@ -248,6 +595,23 @@ export namespace BatchFailedWebhookEvent {
   }
 }
 
+export interface DeletedWebhookEndpoint {
+  /**
+   * The ID of the deleted webhook endpoint.
+   */
+  id: string;
+
+  /**
+   * Whether the endpoint was deleted.
+   */
+  deleted: boolean;
+
+  /**
+   * The object type, which is always webhook_endpoint.deleted.
+   */
+  object: 'webhook_endpoint.deleted';
+}
+
 /**
  * Sent when an eval run has been canceled.
  */
@@ -552,6 +916,14 @@ export namespace LiveCallIncomingWebhookEvent {
      * untrusted call metadata.
      */
     sip_headers: Array<Data.SipHeader>;
+
+    /**
+     * Media protection selected on the SIP leg during SDP negotiation. `srtp`
+     * indicates SRTP; `rtp` indicates unencrypted RTP. Omitted when unknown. This does
+     * not describe SIP signaling security or confirm that media has flowed. Clients
+     * should handle unrecognized values as unknown.
+     */
+    sip_media_security?: 'rtp' | 'srtp' | (string & {});
   }
 
   export namespace Data {
@@ -626,6 +998,14 @@ export namespace LiveTransportIncomingWebhookEvent {
      * The incoming transport type. Always `sip`.
      */
     type: 'sip';
+
+    /**
+     * Media protection selected on the SIP leg during SDP negotiation. `srtp`
+     * indicates SRTP; `rtp` indicates unencrypted RTP. Omitted when unknown. This does
+     * not describe SIP signaling security or confirm that media has flowed. Clients
+     * should handle unrecognized values as unknown.
+     */
+    sip_media_security?: 'rtp' | 'srtp' | (string & {});
   }
 
   export namespace Data {
@@ -696,6 +1076,14 @@ export namespace RealtimeCallIncomingWebhookEvent {
      * untrusted call metadata.
      */
     sip_headers: Array<Data.SipHeader>;
+
+    /**
+     * Media protection selected on the SIP leg during SDP negotiation. `srtp`
+     * indicates SRTP; `rtp` indicates unencrypted RTP. Omitted when unknown. This does
+     * not describe SIP signaling security or confirm that media has flowed. Clients
+     * should handle unrecognized values as unknown.
+     */
+    sip_media_security?: 'rtp' | 'srtp' | (string & {});
   }
 
   export namespace Data {
@@ -920,6 +1308,42 @@ export namespace SafetyAlertCreatedWebhookEvent {
   }
 }
 
+/**
+ * Sent when a deactivation is issued for a safety identifier in your organization.
+ */
+export interface SafetyDeactivationIssuedWebhookEvent {
+  /**
+   * The unique ID of the webhook event.
+   */
+  id: string;
+
+  /**
+   * The Unix timestamp in seconds when the event was created.
+   */
+  created_at: number;
+
+  data: SafetyDeactivationIssuedWebhookEvent.Data;
+
+  /**
+   * Always `event`.
+   */
+  object: 'event';
+
+  /**
+   * Always `safety.deactivation_issued`.
+   */
+  type: 'safety.deactivation_issued';
+}
+
+export namespace SafetyDeactivationIssuedWebhookEvent {
+  export interface Data {
+    /**
+     * The safety case ID to pass to `GET /v1/safety/cases/{id}`.
+     */
+    id: string;
+  }
+}
+
 /**
  * Sent when an approved safety alert is available for an enterprise workspace.
  */
@@ -956,6 +1380,42 @@ export namespace SafetyOrgAlertCreatedWebhookEvent {
   }
 }
 
+/**
+ * Sent when a warning is issued for a safety identifier in your organization.
+ */
+export interface SafetyWarningIssuedWebhookEvent {
+  /**
+   * The unique ID of the webhook event.
+   */
+  id: string;
+
+  /**
+   * The Unix timestamp in seconds when the event was created.
+   */
+  created_at: number;
+
+  data: SafetyWarningIssuedWebhookEvent.Data;
+
+  /**
+   * Always `event`.
+   */
+  object: 'event';
+
+  /**
+   * Always `safety.warning_issued`.
+   */
+  type: 'safety.warning_issued';
+}
+
+export namespace SafetyWarningIssuedWebhookEvent {
+  export interface Data {
+    /**
+     * The safety case ID to pass to `GET /v1/safety/cases/{id}`.
+     */
+    id: string;
+  }
+}
+
 /**
  * Sent when a batch API request has been cancelled.
  */
@@ -978,7 +1438,282 @@ export type UnwrapWebhookEvent =
   | ResponseFailedWebhookEvent
   | ResponseIncompleteWebhookEvent
   | SafetyAlertCreatedWebhookEvent
-  | SafetyOrgAlertCreatedWebhookEvent;
+  | SafetyDeactivationIssuedWebhookEvent
+  | SafetyOrgAlertCreatedWebhookEvent
+  | SafetyWarningIssuedWebhookEvent;
+
+export interface WebhookEndpoint {
+  /**
+   * The unique ID of the webhook endpoint.
+   */
+  id: string;
+
+  /**
+   * The Unix timestamp when the endpoint was created.
+   */
+  created_at: number;
+
+  /**
+   * The event types that trigger deliveries to this endpoint.
+   */
+  event_types: Array<string>;
+
+  /**
+   * The human-readable name of the endpoint.
+   */
+  name: string;
+
+  /**
+   * The object type, which is always webhook_endpoint.
+   */
+  object: 'webhook_endpoint';
+
+  /**
+   * A masked hint for the endpoint's signing secret.
+   */
+  signing_secret_hint: string | null;
+
+  /**
+   * The HTTPS URL that receives webhook deliveries.
+   */
+  url: string;
+
+  /**
+   * The Unix timestamp of the last endpoint configuration or signing-secret change.
+   * Initialized at creation; tests and unchanged updates do not advance it.
+   */
+  updated_at?: number;
+}
+
+export interface WebhookEndpointList {
+  /**
+   * The webhook endpoints in this page.
+   */
+  data: Array<WebhookEndpoint>;
+
+  /**
+   * The ID of the first endpoint in this page.
+   */
+  first_id: string | null;
+
+  /**
+   * Whether more webhook endpoints are available.
+   */
+  has_more: boolean;
+
+  /**
+   * The ID of the last endpoint in this page.
+   */
+  last_id: string | null;
+
+  /**
+   * The object type, which is always list.
+   */
+  object: 'list';
+}
+
+export interface WebhookEndpointTestResult {
+  /**
+   * The event type sent in the test.
+   */
+  event_type: string;
+
+  /**
+   * The object type, which is always webhook_endpoint.test.
+   */
+  object: 'webhook_endpoint.test';
+
+  /**
+   * The HTTP status code returned by the endpoint.
+   */
+  status_code: number;
+
+  /**
+   * Whether the test request completed. Always true for returned results; use
+   * status_code to determine the endpoint response.
+   */
+  success: true;
+
+  /**
+   * The ID of the webhook endpoint that received the test.
+   */
+  webhook_endpoint_id: string;
+}
+
+export interface WebhookEndpointWithSecret {
+  /**
+   * The unique ID of the webhook endpoint.
+   */
+  id: string;
+
+  /**
+   * The Unix timestamp when the endpoint was created.
+   */
+  created_at: number;
+
+  /**
+   * The event types that trigger deliveries to this endpoint.
+   */
+  event_types: Array<string>;
+
+  /**
+   * The human-readable name of the endpoint.
+   */
+  name: string;
+
+  /**
+   * The object type, which is always webhook_endpoint.
+   */
+  object: 'webhook_endpoint';
+
+  /**
+   * The endpoint's signing secret. This is returned only when the endpoint is
+   * created or the secret is rotated.
+   */
+  signing_secret: string;
+
+  /**
+   * A masked hint for the endpoint's signing secret.
+   */
+  signing_secret_hint: string | null;
+
+  /**
+   * The HTTPS URL that receives webhook deliveries.
+   */
+  url: string;
+
+  /**
+   * The Unix timestamp of the last endpoint configuration or signing-secret change.
+   * Initialized at creation; tests and unchanged updates do not advance it.
+   */
+  updated_at?: number;
+}
+
+export interface WebhookEventTypeList {
+  /**
+   * The webhook event types available to the authenticated project.
+   */
+  data: Array<string>;
+
+  /**
+   * The object type, which is always list.
+   */
+  object: 'list';
+}
+
+export interface WebhookCreateParams {
+  /**
+   * The event types that trigger deliveries to this endpoint.
+   */
+  event_types: Array<
+    | 'batch.completed'
+    | 'batch.failed'
+    | 'batch.expired'
+    | 'batch.cancelled'
+    | 'response.completed'
+    | 'response.failed'
+    | 'response.cancelled'
+    | 'response.incomplete'
+    | 'eval.run.succeeded'
+    | 'eval.run.failed'
+    | 'eval.run.canceled'
+    | 'fine_tuning.job.succeeded'
+    | 'fine_tuning.job.failed'
+    | 'fine_tuning.job.cancelled'
+    | 'realtime.call.incoming'
+    | 'video.completed'
+    | 'video.failed'
+    | 'safety.alert.created'
+  >;
+
+  /**
+   * A human-readable name for the webhook endpoint.
+   */
+  name: string;
+
+  /**
+   * The HTTPS URL that receives webhook deliveries.
+   */
+  url: string;
+}
+
+export interface WebhookUpdateParams {
+  /**
+   * The complete set of event types that should trigger deliveries.
+   */
+  event_types?: Array<
+    | 'batch.completed'
+    | 'batch.failed'
+    | 'batch.expired'
+    | 'batch.cancelled'
+    | 'response.completed'
+    | 'response.failed'
+    | 'response.cancelled'
+    | 'response.incomplete'
+    | 'eval.run.succeeded'
+    | 'eval.run.failed'
+    | 'eval.run.canceled'
+    | 'fine_tuning.job.succeeded'
+    | 'fine_tuning.job.failed'
+    | 'fine_tuning.job.cancelled'
+    | 'realtime.call.incoming'
+    | 'video.completed'
+    | 'video.failed'
+    | 'safety.alert.created'
+  >;
+
+  /**
+   * A new human-readable name for the webhook endpoint.
+   */
+  name?: string;
+
+  /**
+   * A new HTTPS URL that receives webhook deliveries.
+   */
+  url?: string;
+}
+
+export interface WebhookListParams extends Omit<CursorPageParams, 'after'> {
+  /**
+   * ID of the last webhook endpoint from the previous page.
+   */
+  after?: string | null;
+}
+
+export interface WebhookRotateSecretParams {
+  /**
+   * Whether to keep the previous signing secret valid for 24 hours after rotation.
+   * Defaults to false, which invalidates the previous secret immediately.
+   */
+  keep_old_secret_active_for_24_hours?: boolean;
+}
+
+export interface WebhookTestParams {
+  /**
+   * The event type to send as a sample delivery.
+   */
+  event_type:
+    | 'batch.completed'
+    | 'batch.failed'
+    | 'batch.expired'
+    | 'batch.cancelled'
+    | 'response.completed'
+    | 'response.failed'
+    | 'response.cancelled'
+    | 'response.incomplete'
+    | 'eval.run.succeeded'
+    | 'eval.run.failed'
+    | 'eval.run.canceled'
+    | 'fine_tuning.job.succeeded'
+    | 'fine_tuning.job.failed'
+    | 'fine_tuning.job.cancelled'
+    | 'realtime.call.incoming'
+    | 'video.completed'
+    | 'video.failed'
+    | 'safety.alert.created';
+}
+
+Webhooks.EventTypes = EventTypes;
 
 export declare namespace Webhooks {
   export {
@@ -986,6 +1721,7 @@ export declare namespace Webhooks {
     type BatchCompletedWebhookEvent as BatchCompletedWebhookEvent,
     type BatchExpiredWebhookEvent as BatchExpiredWebhookEvent,
     type BatchFailedWebhookEvent as BatchFailedWebhookEvent,
+    type DeletedWebhookEndpoint as DeletedWebhookEndpoint,
     type EvalRunCanceledWebhookEvent as EvalRunCanceledWebhookEvent,
     type EvalRunFailedWebhookEvent as EvalRunFailedWebhookEvent,
     type EvalRunSucceededWebhookEvent as EvalRunSucceededWebhookEvent,
@@ -1000,7 +1736,22 @@ export declare namespace Webhooks {
     type ResponseFailedWebhookEvent as ResponseFailedWebhookEvent,
     type ResponseIncompleteWebhookEvent as ResponseIncompleteWebhookEvent,
     type SafetyAlertCreatedWebhookEvent as SafetyAlertCreatedWebhookEvent,
+    type SafetyDeactivationIssuedWebhookEvent as SafetyDeactivationIssuedWebhookEvent,
     type SafetyOrgAlertCreatedWebhookEvent as SafetyOrgAlertCreatedWebhookEvent,
+    type SafetyWarningIssuedWebhookEvent as SafetyWarningIssuedWebhookEvent,
     type UnwrapWebhookEvent as UnwrapWebhookEvent,
+    type WebhookEndpoint as WebhookEndpoint,
+    type WebhookEndpointList as WebhookEndpointList,
+    type WebhookEndpointTestResult as WebhookEndpointTestResult,
+    type WebhookEndpointWithSecret as WebhookEndpointWithSecret,
+    type WebhookEventTypeList as WebhookEventTypeList,
+    type WebhookEndpointsPage as WebhookEndpointsPage,
+    type WebhookCreateParams as WebhookCreateParams,
+    type WebhookUpdateParams as WebhookUpdateParams,
+    type WebhookListParams as WebhookListParams,
+    type WebhookRotateSecretParams as WebhookRotateSecretParams,
+    type WebhookTestParams as WebhookTestParams,
   };
+
+  export { EventTypes as EventTypes };
 }