@polar-sh/sdk 0.40.1 → 0.40.3

package/src/models/components/seatassign.ts

@@ -37,6 +37,10 @@ export type SeatAssign = {
    * Additional metadata for the seat (max 10 keys, 1KB total)
    */
   metadata?: { [k: string]: any } | null | undefined;
+  /**
+   * If true, the seat will be immediately claimed without sending an invitation email. API-only feature.
+   */
+  immediateClaim?: boolean | undefined;
 };
 
 /** @internal */
@@ -52,6 +56,7 @@ export const SeatAssign$inboundSchema: z.ZodType<
   external_customer_id: z.nullable(z.string()).optional(),
   customer_id: z.nullable(z.string()).optional(),
   metadata: z.nullable(z.record(z.any())).optional(),
+  immediate_claim: z.boolean().default(false),
 }).transform((v) => {
   return remap$(v, {
     "subscription_id": "subscriptionId",
@@ -59,6 +64,7 @@ export const SeatAssign$inboundSchema: z.ZodType<
     "order_id": "orderId",
     "external_customer_id": "externalCustomerId",
     "customer_id": "customerId",
+    "immediate_claim": "immediateClaim",
   });
 });
 
@@ -71,6 +77,7 @@ export type SeatAssign$Outbound = {
   external_customer_id?: string | null | undefined;
   customer_id?: string | null | undefined;
   metadata?: { [k: string]: any } | null | undefined;
+  immediate_claim: boolean;
 };
 
 /** @internal */
@@ -86,6 +93,7 @@ export const SeatAssign$outboundSchema: z.ZodType<
   externalCustomerId: z.nullable(z.string()).optional(),
   customerId: z.nullable(z.string()).optional(),
   metadata: z.nullable(z.record(z.any())).optional(),
+  immediateClaim: z.boolean().default(false),
 }).transform((v) => {
   return remap$(v, {
     subscriptionId: "subscription_id",
@@ -93,6 +101,7 @@ export const SeatAssign$outboundSchema: z.ZodType<
     orderId: "order_id",
     externalCustomerId: "external_customer_id",
     customerId: "customer_id",
+    immediateClaim: "immediate_claim",
   });
 });
 

package/src/models/components/systemevent.ts

@@ -30,6 +30,24 @@ import {
   BenefitUpdatedEvent$Outbound,
   BenefitUpdatedEvent$outboundSchema,
 } from "./benefitupdatedevent.js";
+import {
+  CustomerCreatedEvent,
+  CustomerCreatedEvent$inboundSchema,
+  CustomerCreatedEvent$Outbound,
+  CustomerCreatedEvent$outboundSchema,
+} from "./customercreatedevent.js";
+import {
+  CustomerDeletedEvent,
+  CustomerDeletedEvent$inboundSchema,
+  CustomerDeletedEvent$Outbound,
+  CustomerDeletedEvent$outboundSchema,
+} from "./customerdeletedevent.js";
+import {
+  CustomerUpdatedEvent,
+  CustomerUpdatedEvent$inboundSchema,
+  CustomerUpdatedEvent$Outbound,
+  CustomerUpdatedEvent$outboundSchema,
+} from "./customerupdatedevent.js";
 import {
   MeterCreditEvent,
   MeterCreditEvent$inboundSchema,
@@ -42,6 +60,18 @@ import {
   MeterResetEvent$Outbound,
   MeterResetEvent$outboundSchema,
 } from "./meterresetevent.js";
+import {
+  OrderPaidEvent,
+  OrderPaidEvent$inboundSchema,
+  OrderPaidEvent$Outbound,
+  OrderPaidEvent$outboundSchema,
+} from "./orderpaidevent.js";
+import {
+  OrderRefundedEvent,
+  OrderRefundedEvent$inboundSchema,
+  OrderRefundedEvent$Outbound,
+  OrderRefundedEvent$outboundSchema,
+} from "./orderrefundedevent.js";
 import {
   SubscriptionCycledEvent,
   SubscriptionCycledEvent$inboundSchema,
@@ -66,8 +96,13 @@ export type SystemEvent =
   | (BenefitGrantedEvent & { name: "benefit.granted" })
   | (BenefitRevokedEvent & { name: "benefit.revoked" })
   | (BenefitUpdatedEvent & { name: "benefit.updated" })
+  | (CustomerCreatedEvent & { name: "customer.created" })
+  | (CustomerDeletedEvent & { name: "customer.deleted" })
+  | (CustomerUpdatedEvent & { name: "customer.updated" })
   | (MeterCreditEvent & { name: "meter.credited" })
   | (MeterResetEvent & { name: "meter.reset" })
+  | (OrderPaidEvent & { name: "order.paid" })
+  | (OrderRefundedEvent & { name: "order.refunded" })
   | (SubscriptionCycledEvent & { name: "subscription.cycled" })
   | (SubscriptionProductUpdatedEvent & { name: "subscription.product_updated" })
   | (SubscriptionRevokedEvent & { name: "subscription.revoked" });
@@ -98,6 +133,21 @@ export const SystemEvent$inboundSchema: z.ZodType<
       name: v.name,
     })),
   ),
+  CustomerCreatedEvent$inboundSchema.and(
+    z.object({ name: z.literal("customer.created") }).transform((v) => ({
+      name: v.name,
+    })),
+  ),
+  CustomerDeletedEvent$inboundSchema.and(
+    z.object({ name: z.literal("customer.deleted") }).transform((v) => ({
+      name: v.name,
+    })),
+  ),
+  CustomerUpdatedEvent$inboundSchema.and(
+    z.object({ name: z.literal("customer.updated") }).transform((v) => ({
+      name: v.name,
+    })),
+  ),
   MeterCreditEvent$inboundSchema.and(
     z.object({ name: z.literal("meter.credited") }).transform((v) => ({
       name: v.name,
@@ -108,6 +158,16 @@ export const SystemEvent$inboundSchema: z.ZodType<
       name: v.name,
     })),
   ),
+  OrderPaidEvent$inboundSchema.and(
+    z.object({ name: z.literal("order.paid") }).transform((v) => ({
+      name: v.name,
+    })),
+  ),
+  OrderRefundedEvent$inboundSchema.and(
+    z.object({ name: z.literal("order.refunded") }).transform((v) => ({
+      name: v.name,
+    })),
+  ),
   SubscriptionCycledEvent$inboundSchema.and(
     z.object({ name: z.literal("subscription.cycled") }).transform((v) => ({
       name: v.name,
@@ -131,8 +191,13 @@ export type SystemEvent$Outbound =
   | (BenefitGrantedEvent$Outbound & { name: "benefit.granted" })
   | (BenefitRevokedEvent$Outbound & { name: "benefit.revoked" })
   | (BenefitUpdatedEvent$Outbound & { name: "benefit.updated" })
+  | (CustomerCreatedEvent$Outbound & { name: "customer.created" })
+  | (CustomerDeletedEvent$Outbound & { name: "customer.deleted" })
+  | (CustomerUpdatedEvent$Outbound & { name: "customer.updated" })
   | (MeterCreditEvent$Outbound & { name: "meter.credited" })
   | (MeterResetEvent$Outbound & { name: "meter.reset" })
+  | (OrderPaidEvent$Outbound & { name: "order.paid" })
+  | (OrderRefundedEvent$Outbound & { name: "order.refunded" })
   | (SubscriptionCycledEvent$Outbound & { name: "subscription.cycled" })
   | (SubscriptionProductUpdatedEvent$Outbound & {
     name: "subscription.product_updated";
@@ -165,6 +230,21 @@ export const SystemEvent$outboundSchema: z.ZodType<
       name: v.name,
     })),
   ),
+  CustomerCreatedEvent$outboundSchema.and(
+    z.object({ name: z.literal("customer.created") }).transform((v) => ({
+      name: v.name,
+    })),
+  ),
+  CustomerDeletedEvent$outboundSchema.and(
+    z.object({ name: z.literal("customer.deleted") }).transform((v) => ({
+      name: v.name,
+    })),
+  ),
+  CustomerUpdatedEvent$outboundSchema.and(
+    z.object({ name: z.literal("customer.updated") }).transform((v) => ({
+      name: v.name,
+    })),
+  ),
   MeterCreditEvent$outboundSchema.and(
     z.object({ name: z.literal("meter.credited") }).transform((v) => ({
       name: v.name,
@@ -175,6 +255,16 @@ export const SystemEvent$outboundSchema: z.ZodType<
       name: v.name,
     })),
   ),
+  OrderPaidEvent$outboundSchema.and(
+    z.object({ name: z.literal("order.paid") }).transform((v) => ({
+      name: v.name,
+    })),
+  ),
+  OrderRefundedEvent$outboundSchema.and(
+    z.object({ name: z.literal("order.refunded") }).transform((v) => ({
+      name: v.name,
+    })),
+  ),
   SubscriptionCycledEvent$outboundSchema.and(
     z.object({ name: z.literal("subscription.cycled") }).transform((v) => ({
       name: v.name,

package/src/models/components/wallet.ts

@@ -0,0 +1,121 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * A wallet represents a customer's balance in your organization.
+ *
+ * @remarks
+ *
+ * They can top-up their wallet, and use the balance to pay for usage.
+ */
+export type Wallet = {
+  /**
+   * The ID of the object.
+   */
+  id: string;
+  /**
+   * Creation timestamp of the object.
+   */
+  createdAt: Date;
+  /**
+   * Last modification timestamp of the object.
+   */
+  modifiedAt: Date | null;
+  /**
+   * The ID of the customer that owns the wallet.
+   */
+  customerId: string;
+  /**
+   * The current balance of the wallet, in cents.
+   */
+  balance: number;
+  /**
+   * The currency of the wallet.
+   */
+  currency: string;
+};
+
+/** @internal */
+export const Wallet$inboundSchema: z.ZodType<Wallet, z.ZodTypeDef, unknown> = z
+  .object({
+    id: z.string(),
+    created_at: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ),
+    modified_at: z.nullable(
+      z.string().datetime({ offset: true }).transform(v => new Date(v)),
+    ),
+    customer_id: z.string(),
+    balance: z.number().int(),
+    currency: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      "created_at": "createdAt",
+      "modified_at": "modifiedAt",
+      "customer_id": "customerId",
+    });
+  });
+
+/** @internal */
+export type Wallet$Outbound = {
+  id: string;
+  created_at: string;
+  modified_at: string | null;
+  customer_id: string;
+  balance: number;
+  currency: string;
+};
+
+/** @internal */
+export const Wallet$outboundSchema: z.ZodType<
+  Wallet$Outbound,
+  z.ZodTypeDef,
+  Wallet
+> = z.object({
+  id: z.string(),
+  createdAt: z.date().transform(v => v.toISOString()),
+  modifiedAt: z.nullable(z.date().transform(v => v.toISOString())),
+  customerId: z.string(),
+  balance: z.number().int(),
+  currency: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    createdAt: "created_at",
+    modifiedAt: "modified_at",
+    customerId: "customer_id",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Wallet$ {
+  /** @deprecated use `Wallet$inboundSchema` instead. */
+  export const inboundSchema = Wallet$inboundSchema;
+  /** @deprecated use `Wallet$outboundSchema` instead. */
+  export const outboundSchema = Wallet$outboundSchema;
+  /** @deprecated use `Wallet$Outbound` instead. */
+  export type Outbound = Wallet$Outbound;
+}
+
+export function walletToJSON(wallet: Wallet): string {
+  return JSON.stringify(Wallet$outboundSchema.parse(wallet));
+}
+
+export function walletFromJSON(
+  jsonString: string,
+): SafeParseResult<Wallet, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Wallet$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Wallet' from JSON`,
+  );
+}

package/src/models/components/walletsortproperty.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const WalletSortProperty = {
+  CreatedAt: "created_at",
+  MinusCreatedAt: "-created_at",
+  Balance: "balance",
+  MinusBalance: "-balance",
+} as const;
+export type WalletSortProperty = ClosedEnum<typeof WalletSortProperty>;
+
+/** @internal */
+export const WalletSortProperty$inboundSchema: z.ZodNativeEnum<
+  typeof WalletSortProperty
+> = z.nativeEnum(WalletSortProperty);
+
+/** @internal */
+export const WalletSortProperty$outboundSchema: z.ZodNativeEnum<
+  typeof WalletSortProperty
+> = WalletSortProperty$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace WalletSortProperty$ {
+  /** @deprecated use `WalletSortProperty$inboundSchema` instead. */
+  export const inboundSchema = WalletSortProperty$inboundSchema;
+  /** @deprecated use `WalletSortProperty$outboundSchema` instead. */
+  export const outboundSchema = WalletSortProperty$outboundSchema;
+}

package/src/models/components/wallettopupcreate.ts

@@ -0,0 +1,79 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Request schema to top-up a wallet.
+ */
+export type WalletTopUpCreate = {
+  /**
+   * The amount to top-up the wallet by, in cents.
+   */
+  amount: number;
+  /**
+   * The currency. Currently, only `usd` is supported. It should match the wallet's currency.
+   */
+  currency: string;
+};
+
+/** @internal */
+export const WalletTopUpCreate$inboundSchema: z.ZodType<
+  WalletTopUpCreate,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  amount: z.number().int(),
+  currency: z.string(),
+});
+
+/** @internal */
+export type WalletTopUpCreate$Outbound = {
+  amount: number;
+  currency: string;
+};
+
+/** @internal */
+export const WalletTopUpCreate$outboundSchema: z.ZodType<
+  WalletTopUpCreate$Outbound,
+  z.ZodTypeDef,
+  WalletTopUpCreate
+> = z.object({
+  amount: z.number().int(),
+  currency: z.string(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace WalletTopUpCreate$ {
+  /** @deprecated use `WalletTopUpCreate$inboundSchema` instead. */
+  export const inboundSchema = WalletTopUpCreate$inboundSchema;
+  /** @deprecated use `WalletTopUpCreate$outboundSchema` instead. */
+  export const outboundSchema = WalletTopUpCreate$outboundSchema;
+  /** @deprecated use `WalletTopUpCreate$Outbound` instead. */
+  export type Outbound = WalletTopUpCreate$Outbound;
+}
+
+export function walletTopUpCreateToJSON(
+  walletTopUpCreate: WalletTopUpCreate,
+): string {
+  return JSON.stringify(
+    WalletTopUpCreate$outboundSchema.parse(walletTopUpCreate),
+  );
+}
+
+export function walletTopUpCreateFromJSON(
+  jsonString: string,
+): SafeParseResult<WalletTopUpCreate, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => WalletTopUpCreate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'WalletTopUpCreate' from JSON`,
+  );
+}

package/src/models/components/webhookendpoint.ts

@@ -51,6 +51,10 @@ export type WebhookEndpoint = {
    * The events that will trigger the webhook.
    */
   events: Array<WebhookEventType>;
+  /**
+   * Whether the webhook endpoint is enabled and will receive events.
+   */
+  enabled: boolean;
 };
 
 /** @internal */
@@ -69,6 +73,7 @@ export const WebhookEndpoint$inboundSchema: z.ZodType<
   secret: z.string(),
   organization_id: z.string(),
   events: z.array(WebhookEventType$inboundSchema),
+  enabled: z.boolean(),
 }).transform((v) => {
   return remap$(v, {
     "created_at": "createdAt",
@@ -87,6 +92,7 @@ export type WebhookEndpoint$Outbound = {
   secret: string;
   organization_id: string;
   events: Array<string>;
+  enabled: boolean;
 };
 
 /** @internal */
@@ -103,6 +109,7 @@ export const WebhookEndpoint$outboundSchema: z.ZodType<
   secret: z.string(),
   organizationId: z.string(),
   events: z.array(WebhookEventType$outboundSchema),
+  enabled: z.boolean(),
 }).transform((v) => {
   return remap$(v, {
     createdAt: "created_at",

package/src/models/components/webhookendpointupdate.ts

@@ -28,6 +28,10 @@ export type WebhookEndpointUpdate = {
   secret?: string | null | undefined;
   format?: WebhookFormat | null | undefined;
   events?: Array<WebhookEventType> | null | undefined;
+  /**
+   * Whether the webhook endpoint is enabled.
+   */
+  enabled?: boolean | null | undefined;
 };
 
 /** @internal */
@@ -40,6 +44,7 @@ export const WebhookEndpointUpdate$inboundSchema: z.ZodType<
   secret: z.nullable(z.string()).optional(),
   format: z.nullable(WebhookFormat$inboundSchema).optional(),
   events: z.nullable(z.array(WebhookEventType$inboundSchema)).optional(),
+  enabled: z.nullable(z.boolean()).optional(),
 });
 
 /** @internal */
@@ -48,6 +53,7 @@ export type WebhookEndpointUpdate$Outbound = {
   secret?: string | null | undefined;
   format?: string | null | undefined;
   events?: Array<string> | null | undefined;
+  enabled?: boolean | null | undefined;
 };
 
 /** @internal */
@@ -60,6 +66,7 @@ export const WebhookEndpointUpdate$outboundSchema: z.ZodType<
   secret: z.nullable(z.string()).optional(),
   format: z.nullable(WebhookFormat$outboundSchema).optional(),
   events: z.nullable(z.array(WebhookEventType$outboundSchema)).optional(),
+  enabled: z.nullable(z.boolean()).optional(),
 });
 
 /**

package/src/models/errors/missingpaymentmethoderror.ts

@@ -0,0 +1,85 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { PolarError } from "./polarerror.js";
+
+export type MissingPaymentMethodErrorData = {
+  error: "MissingPaymentMethodError";
+  detail: string;
+};
+
+export class MissingPaymentMethodError extends PolarError {
+  error: "MissingPaymentMethodError";
+  detail: string;
+
+  /** The original data that was passed to this error instance. */
+  data$: MissingPaymentMethodErrorData;
+
+  constructor(
+    err: MissingPaymentMethodErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = "message" in err && typeof err.message === "string"
+      ? err.message
+      : `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+    this.detail = err.detail;
+
+    this.name = "MissingPaymentMethodError";
+  }
+}
+
+/** @internal */
+export const MissingPaymentMethodError$inboundSchema: z.ZodType<
+  MissingPaymentMethodError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  error: z.literal("MissingPaymentMethodError"),
+  detail: z.string(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new MissingPaymentMethodError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
+
+/** @internal */
+export type MissingPaymentMethodError$Outbound = {
+  error: "MissingPaymentMethodError";
+  detail: string;
+};
+
+/** @internal */
+export const MissingPaymentMethodError$outboundSchema: z.ZodType<
+  MissingPaymentMethodError$Outbound,
+  z.ZodTypeDef,
+  MissingPaymentMethodError
+> = z.instanceof(MissingPaymentMethodError)
+  .transform(v => v.data$)
+  .pipe(z.object({
+    error: z.literal("MissingPaymentMethodError"),
+    detail: z.string(),
+  }));
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace MissingPaymentMethodError$ {
+  /** @deprecated use `MissingPaymentMethodError$inboundSchema` instead. */
+  export const inboundSchema = MissingPaymentMethodError$inboundSchema;
+  /** @deprecated use `MissingPaymentMethodError$outboundSchema` instead. */
+  export const outboundSchema = MissingPaymentMethodError$outboundSchema;
+  /** @deprecated use `MissingPaymentMethodError$Outbound` instead. */
+  export type Outbound = MissingPaymentMethodError$Outbound;
+}

package/src/models/errors/paymentintentfailederror.ts

@@ -0,0 +1,85 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { PolarError } from "./polarerror.js";
+
+export type PaymentIntentFailedErrorData = {
+  error: "PaymentIntentFailedError";
+  detail: string;
+};
+
+export class PaymentIntentFailedError extends PolarError {
+  error: "PaymentIntentFailedError";
+  detail: string;
+
+  /** The original data that was passed to this error instance. */
+  data$: PaymentIntentFailedErrorData;
+
+  constructor(
+    err: PaymentIntentFailedErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = "message" in err && typeof err.message === "string"
+      ? err.message
+      : `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.error = err.error;
+    this.detail = err.detail;
+
+    this.name = "PaymentIntentFailedError";
+  }
+}
+
+/** @internal */
+export const PaymentIntentFailedError$inboundSchema: z.ZodType<
+  PaymentIntentFailedError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  error: z.literal("PaymentIntentFailedError"),
+  detail: z.string(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new PaymentIntentFailedError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
+
+/** @internal */
+export type PaymentIntentFailedError$Outbound = {
+  error: "PaymentIntentFailedError";
+  detail: string;
+};
+
+/** @internal */
+export const PaymentIntentFailedError$outboundSchema: z.ZodType<
+  PaymentIntentFailedError$Outbound,
+  z.ZodTypeDef,
+  PaymentIntentFailedError
+> = z.instanceof(PaymentIntentFailedError)
+  .transform(v => v.data$)
+  .pipe(z.object({
+    error: z.literal("PaymentIntentFailedError"),
+    detail: z.string(),
+  }));
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace PaymentIntentFailedError$ {
+  /** @deprecated use `PaymentIntentFailedError$inboundSchema` instead. */
+  export const inboundSchema = PaymentIntentFailedError$inboundSchema;
+  /** @deprecated use `PaymentIntentFailedError$outboundSchema` instead. */
+  export const outboundSchema = PaymentIntentFailedError$outboundSchema;
+  /** @deprecated use `PaymentIntentFailedError$Outbound` instead. */
+  export type Outbound = PaymentIntentFailedError$Outbound;
+}