@faire-auth/stripe 1.1.0 → 1.1.1

package/dist/index-D4yUrDJc.d.mts

@@ -0,0 +1,1005 @@
+import { ContextVars, InferOptionSchema } from "faire-auth";
+import Stripe from "stripe";
+import * as z from "zod";
+import { Session, User } from "faire-auth/db";
+import { Context } from "@faire-auth/core/types";
+declare const subscriptions: {
+  subscription: {
+    fields: {
+      plan: {
+        type: "string";
+        required: true;
+      };
+      referenceId: {
+        type: "string";
+        required: true;
+      };
+      stripeCustomerId: {
+        type: "string";
+        required: false;
+      };
+      stripeSubscriptionId: {
+        type: "string";
+        required: false;
+      };
+      status: {
+        type: "string";
+        defaultValue: string;
+      };
+      periodStart: {
+        type: "date";
+        required: false;
+      };
+      periodEnd: {
+        type: "date";
+        required: false;
+      };
+      trialStart: {
+        type: "date";
+        required: false;
+      };
+      trialEnd: {
+        type: "date";
+        required: false;
+      };
+      cancelAtPeriodEnd: {
+        type: "boolean";
+        required: false;
+        defaultValue: false;
+      };
+      seats: {
+        type: "number";
+        required: false;
+      };
+    };
+  };
+};
+declare const user: {
+  user: {
+    fields: {
+      stripeCustomerId: {
+        type: "string";
+        required: false;
+      };
+    };
+  };
+};
+type StripePlan = {
+  /**
+   * Monthly price id
+   */
+  priceId?: string;
+  /**
+   * To use lookup key instead of price id
+   *
+   * https://docs.stripe.com/products-prices/
+   * manage-prices#lookup-keys
+   */
+  lookupKey?: string;
+  /**
+   * A yearly discount price id
+   *
+   * useful when you want to offer a discount for
+   * yearly subscription
+   */
+  annualDiscountPriceId?: string;
+  /**
+   * To use lookup key instead of price id
+   *
+   * https://docs.stripe.com/products-prices/
+   * manage-prices#lookup-keys
+   */
+  annualDiscountLookupKey?: string;
+  /**
+   * Plan name
+   */
+  name: string;
+  /**
+   * Limits for the plan
+   */
+  limits?: Record<string, number>;
+  /**
+   * Plan group name
+   *
+   * useful when you want to group plans or
+   * when a user can subscribe to multiple plans.
+   */
+  group?: string;
+  /**
+   * Free trial days
+   */
+  freeTrial?: {
+    /**
+     * Number of days
+     */
+    days: number;
+    /**
+     * A function that will be called when the trial
+     * starts.
+     *
+     * @param subscription
+     * @returns
+     */
+    onTrialStart?: (subscription: Subscription) => Promise<void>;
+    /**
+     * A function that will be called when the trial
+     * ends
+     *
+     * @param subscription - Subscription
+     * @returns
+     */
+    onTrialEnd?: <V extends object>(data: {
+      subscription: Subscription;
+    }, ctx: Context<ContextVars<V>>) => Promise<void>;
+    /**
+     * A function that will be called when the trial
+     * expired.
+     * @param subscription - Subscription
+     * @returns
+     */
+    onTrialExpired?: <V extends object>(subscription: Subscription, ctx: Context<ContextVars<V>>) => Promise<void>;
+  };
+};
+interface Subscription {
+  /**
+   * Database identifier
+   */
+  id: string;
+  /**
+   * The plan name
+   */
+  plan: string;
+  /**
+   * Stripe customer id
+   */
+  stripeCustomerId?: string;
+  /**
+   * Stripe subscription id
+   */
+  stripeSubscriptionId?: string;
+  /**
+   * Trial start date
+   */
+  trialStart?: Date;
+  /**
+   * Trial end date
+   */
+  trialEnd?: Date;
+  /**
+   * Price Id for the subscription
+   */
+  priceId?: string;
+  /**
+   * To what reference id the subscription belongs to
+   * @example
+   * - userId for a user
+   * - workspace id for a saas platform
+   * - website id for a hosting platform
+   *
+   * @default - userId
+   */
+  referenceId: string;
+  /**
+   * Subscription status
+   */
+  status: "active" | "canceled" | "incomplete" | "incomplete_expired" | "past_due" | "paused" | "trialing" | "unpaid";
+  /**
+   * The billing cycle start date
+   */
+  periodStart?: Date;
+  /**
+   * The billing cycle end date
+   */
+  periodEnd?: Date;
+  /**
+   * Whether this subscription will (if status=active)
+   * or did (if status=canceled) cancel at the end of the current billing period.
+   */
+  cancelAtPeriodEnd?: boolean;
+  /**
+   * If the subscription is scheduled to be canceled,
+   * this is the time at which the cancellation will take effect.
+   */
+  cancelAt?: Date;
+  /**
+   * If the subscription has been canceled, this is the time when it was canceled.
+   *
+   * Note: If the subscription was canceled with `cancel_at_period_end`,
+   * this reflects the cancellation request time, not when the subscription actually ends.
+   */
+  canceledAt?: Date;
+  /**
+   * If the subscription has ended, the date the subscription ended.
+   */
+  endedAt?: Date;
+  /**
+   * A field to group subscriptions so you can have multiple subscriptions
+   * for one reference id
+   */
+  groupId?: string;
+  /**
+   * Number of seats for the subscription (useful for team plans)
+   */
+  seats?: number;
+}
+interface SubscriptionOptions {
+  enabled: boolean;
+  /**
+   * Subscription Configuration
+   */
+  /**
+   * List of plan
+   */
+  plans: StripePlan[] | (() => StripePlan[] | Promise<StripePlan[]>);
+  /**
+   * Require email verification before a user is allowed to upgrade
+   * their subscriptions
+   *
+   * @default false
+   */
+  requireEmailVerification?: boolean;
+  /**
+   * A callback to run after a user has subscribed to a package
+   * @param event - Stripe Event
+   * @param subscription - Subscription Data
+   * @returns
+   */
+  onSubscriptionComplete?: <V extends object>(data: {
+    event: Stripe.Event;
+    stripeSubscription: Stripe.Subscription;
+    subscription: Subscription;
+    plan: StripePlan;
+  }, ctx: Context<ContextVars<V>>) => Promise<void>;
+  /**
+   * A callback to run after a user is about to cancel their subscription
+   * @returns
+   */
+  onSubscriptionUpdate?: (data: {
+    event: Stripe.Event;
+    subscription: Subscription;
+  }) => Promise<void>;
+  /**
+   * A callback to run after a user is about to cancel their subscription
+   * @returns
+   */
+  onSubscriptionCancel?: (data: {
+    event?: Stripe.Event | undefined;
+    subscription: Subscription;
+    stripeSubscription: Stripe.Subscription;
+    cancellationDetails?: Stripe.Subscription.CancellationDetails | null;
+  }) => Promise<void>;
+  /**
+   * A function to check if the reference id is valid
+   * and belongs to the user
+   *
+   * @param data - data containing user, session and referenceId
+   * @param ctx - the context object
+   * @returns
+   */
+  authorizeReference?: <V extends object>(data: {
+    user: User;
+    session: Session;
+    referenceId: string;
+    action: "upgrade-subscription" | "list-subscription" | "cancel-subscription" | "restore-subscription" | "billing-portal";
+  }, ctx: Context<ContextVars<V>>) => Promise<boolean>;
+  /**
+   * A callback to run after a user has deleted their subscription
+   * @returns
+   */
+  onSubscriptionDeleted?: (data: {
+    event: Stripe.Event;
+    stripeSubscription: Stripe.Subscription;
+    subscription: Subscription;
+  }) => Promise<void>;
+  /**
+   * parameters for session create params
+   *
+   * @param data - data containing user, session and plan
+   * @param ctx - the context object
+   */
+  getCheckoutSessionParams?: <V extends object>(data: {
+    user: User;
+    session: Session;
+    plan: StripePlan;
+    subscription: Subscription;
+  }, ctx: Context<ContextVars<V>>) => Promise<{
+    params?: Stripe.Checkout.SessionCreateParams;
+    options?: Stripe.RequestOptions;
+  }> | {
+    params?: Stripe.Checkout.SessionCreateParams;
+    options?: Stripe.RequestOptions;
+  };
+  /**
+   * Enable organization subscription
+   */
+  organization?: {
+    enabled: boolean;
+  };
+}
+interface StripeOptions {
+  /**
+   * Stripe Client
+   */
+  stripeClient: Stripe;
+  /**
+   * Stripe Webhook Secret
+   *
+   * @description Stripe webhook secret key
+   */
+  stripeWebhookSecret: string;
+  /**
+   * Enable customer creation when a user signs up
+   */
+  createCustomerOnSignUp?: boolean;
+  /**
+   * A callback to run after a customer has been created
+   * @param customer - Customer Data
+   * @param stripeCustomer - Stripe Customer Data
+   * @returns
+   */
+  onCustomerCreate?: <V extends object>(data: {
+    stripeCustomer: Stripe.Customer;
+    user: User;
+  }, ctx: Context<ContextVars<V>>) => Promise<void>;
+  /**
+   * A custom function to get the customer create
+   * params
+   * @param data - data containing user and session
+   * @returns
+   */
+  getCustomerCreateParams?: <V extends object>(data: {
+    user: User;
+    session: Session;
+  }, ctx: Context<ContextVars<V>>) => Promise<{}>;
+  /**
+   * Subscriptions
+   */
+  subscription?: {
+    enabled: false;
+  } | ({
+    enabled: true;
+  } & SubscriptionOptions);
+  /**
+   * A callback to run after a stripe event is received
+   * @param event - Stripe Event
+   * @returns
+   */
+  onEvent?: (event: Stripe.Event) => Promise<void>;
+  /**
+   * Schema for the stripe plugin
+   */
+  schema?: InferOptionSchema<typeof subscriptions & typeof user>;
+}
+declare const stripe: <O extends StripeOptions>(options: O) => {
+  id: "stripe";
+  routes: {
+    stripeWebhook: import("faire-auth").AuthEndpoint<{
+      getRoutingPath: () => "/stripe/webhook";
+      operationId: "stripeWebhook";
+      method: "post";
+      path: "/stripe/webhook";
+      client: false;
+      responses: {
+        200: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.ZodObject<{
+                success: z.ZodLiteral<true>;
+              }, z.core.$strip>;
+            };
+          };
+        };
+      } & {
+        400: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.core.$ZodBranded<z.ZodObject<{
+                success: z.ZodLiteral<false>;
+                code: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+              }, z.core.$strip>, "error", "out">;
+            };
+          };
+        };
+      } & {
+        500: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.core.$ZodBranded<z.ZodObject<{
+                success: z.ZodLiteral<false>;
+                code: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+              }, z.core.$strip>, "error", "out">;
+            };
+          };
+        };
+      };
+    }>;
+  } & (O["subscription"] extends {
+    enabled: boolean;
+  } ? {
+    /**
+     * ### Endpoint
+     *
+     * POST `/subscription/upgrade`
+     *
+     * ### API Methods
+     *
+     * **server:**
+     * `auth.api.upgradeSubscription`
+     *
+     * **client:**
+     * `authClient.subscription.upgrade`
+     *
+     * @see [Read our docs to learn more.](https://faire-auth.com/docs/plugins/stripe#api-method-subscription-upgrade)
+     */
+    readonly upgradeSubscription: import("faire-auth").AuthEndpoint<{
+      getRoutingPath: () => "/subscription/upgrade";
+      operationId: "upgradeSubscription";
+      method: "post";
+      path: "/subscription/upgrade";
+      middleware: [(ctx: import("hono").Context<import("faire-auth").ContextVars<{
+        session: {
+          user: {
+            stripeCustomerId?: string;
+          };
+        };
+      } & {
+        session: {
+          session: Session;
+          user: User;
+        };
+      }>, string, {}>, next: import("hono").Next) => Promise<void | (Response & import("hono").TypedResponse<{
+        success: false;
+        code?: string | undefined;
+        message?: string | undefined;
+      }, 401>)>, (ctx: import("hono").Context<import("faire-auth").ContextVars<object>, string, {}>, next: import("hono").Next) => Promise<void | Response>, (ctx: import("hono").Context<import("faire-auth").ContextVars<{
+        session?: {
+          session: Session;
+          user: User;
+        };
+      }>, "/subscription/billing-portal" | "/subscription/cancel" | "/subscription/list" | "/subscription/restore" | "/subscription/upgrade", {
+        out: {
+          json: {
+            referenceId?: string;
+          };
+          query: {
+            referenceId?: string;
+          };
+        };
+      }>, next: import("hono").Next) => Promise<void | (Response & import("hono").TypedResponse<{
+        success: false;
+      }, 401, "json">) | (Response & import("hono").TypedResponse<{
+        success: false;
+      }, 400, "json">)>];
+      request: {
+        body: {
+          description?: string;
+          content: {
+            "application/json": {
+              schema: z.ZodObject<{
+                plan: z.ZodString;
+                annual: z.ZodOptional<z.ZodBoolean>;
+                referenceId: z.ZodOptional<z.ZodString>;
+                subscriptionId: z.ZodOptional<z.ZodString>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                seats: z.ZodOptional<z.ZodNumber>;
+                successUrl: z.ZodDefault<z.ZodString>;
+                cancelUrl: z.ZodDefault<z.ZodString>;
+                returnUrl: z.ZodOptional<z.ZodString>;
+                disableRedirect: z.ZodDefault<z.ZodBoolean>;
+              }, z.core.$strip>;
+            };
+          };
+          required: true;
+        };
+      };
+      responses: {
+        200: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                redirect: z.ZodLiteral<false>;
+                url: z.ZodDefault<z.ZodNull>;
+              }, z.core.$strip>, z.ZodObject<{
+                redirect: z.ZodLiteral<true>;
+                url: z.ZodURL;
+              }, z.core.$strip>], "redirect">, z.ZodType<Partial<Stripe.Checkout.Session>, Partial<Stripe.Checkout.Session>, z.core.$ZodTypeInternals<Partial<Stripe.Checkout.Session>, Partial<Stripe.Checkout.Session>>>>;
+            };
+          };
+        };
+      } & {
+        400: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.core.$ZodBranded<z.ZodObject<{
+                success: z.ZodLiteral<false>;
+                code: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+              }, z.core.$strip>, "error", "out">;
+            };
+          };
+        };
+      } & {
+        401: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.core.$ZodBranded<z.ZodObject<{
+                success: z.ZodLiteral<false>;
+                code: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+              }, z.core.$strip>, "error", "out">;
+            };
+          };
+        };
+      } & {
+        500: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.core.$ZodBranded<z.ZodObject<{
+                success: z.ZodLiteral<false>;
+                code: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+              }, z.core.$strip>, "error", "out">;
+            };
+          };
+        };
+      };
+    }>;
+    readonly cancelSubscriptionCallback: import("faire-auth").AuthEndpoint<{
+      getRoutingPath: () => "/subscription/cancel/callback";
+      operationId: "cancelSubscriptionCallback";
+      method: "get";
+      path: "/subscription/cancel/callback";
+      middleware: [(ctx: import("hono").Context<import("faire-auth").ContextVars<object>, string, {}>, next: import("hono").Next) => Promise<void | Response>];
+      request: {
+        query: z.ZodObject<{
+          callbackURL: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<string | undefined, string | undefined>, z.ZodOptional<z.ZodURL>>, z.ZodTransform<string | undefined, string | undefined>>>;
+          subscriptionId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+      };
+      responses: {
+        200: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            };
+          };
+        };
+      } & {
+        302: {
+          description: string;
+        };
+      };
+    }>;
+    /**
+     * ### Endpoint
+     *
+     * POST `/subscription/cancel`
+     *
+     * ### API Methods
+     *
+     * **server:**
+     * `auth.api.cancelSubscription`
+     *
+     * **client:**
+     * `authClient.subscription.cancel`
+     *
+     * @see [Read our docs to learn more.](https://faire-auth.com/docs/plugins/stripe#api-method-subscription-cancel)
+     */
+    readonly cancelSubscription: import("faire-auth").AuthEndpoint<{
+      getRoutingPath: () => "/subscription/cancel";
+      operationId: "cancelSubscription";
+      method: "post";
+      path: "/subscription/cancel";
+      middleware: [(ctx: import("hono").Context<import("faire-auth").ContextVars<object & {
+        session: {
+          session: Session;
+          user: User;
+        };
+      }>, string, {}>, next: import("hono").Next) => Promise<void | (Response & import("hono").TypedResponse<{
+        success: false;
+        code?: string | undefined;
+        message?: string | undefined;
+      }, 401>)>, (ctx: import("hono").Context<import("faire-auth").ContextVars<object>, string, {}>, next: import("hono").Next) => Promise<void | Response>, (ctx: import("hono").Context<import("faire-auth").ContextVars<{
+        session?: {
+          session: Session;
+          user: User;
+        };
+      }>, "/subscription/billing-portal" | "/subscription/cancel" | "/subscription/list" | "/subscription/restore" | "/subscription/upgrade", {
+        out: {
+          json: {
+            referenceId?: string;
+          };
+          query: {
+            referenceId?: string;
+          };
+        };
+      }>, next: import("hono").Next) => Promise<void | (Response & import("hono").TypedResponse<{
+        success: false;
+      }, 401, "json">) | (Response & import("hono").TypedResponse<{
+        success: false;
+      }, 400, "json">)>];
+      request: {
+        body: {
+          description?: string;
+          content: {
+            "application/json": {
+              schema: z.ZodObject<{
+                referenceId: z.ZodOptional<z.ZodString>;
+                subscriptionId: z.ZodOptional<z.ZodString>;
+                returnUrl: z.ZodString;
+              }, z.core.$strip>;
+            };
+          };
+          required: true;
+        };
+      };
+      responses: {
+        200: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.ZodObject<{
+                url: z.ZodString;
+                redirect: z.ZodLiteral<true>;
+              }, z.core.$strip>;
+            };
+          };
+        };
+      } & {
+        400: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.core.$ZodBranded<z.ZodObject<{
+                success: z.ZodLiteral<false>;
+                code: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+              }, z.core.$strip>, "error", "out">;
+            };
+          };
+        };
+      } & {
+        401: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.core.$ZodBranded<z.ZodObject<{
+                success: z.ZodLiteral<false>;
+                code: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+              }, z.core.$strip>, "error", "out">;
+            };
+          };
+        };
+      };
+    }>;
+    readonly restoreSubscription: import("faire-auth").AuthEndpoint<{
+      getRoutingPath: () => "/subscription/restore";
+      operationId: "restoreSubscription";
+      method: "post";
+      path: "/subscription/restore";
+      middleware: [(ctx: import("hono").Context<import("faire-auth").ContextVars<object & {
+        session: {
+          session: Session;
+          user: User;
+        };
+      }>, string, {}>, next: import("hono").Next) => Promise<void | (Response & import("hono").TypedResponse<{
+        success: false;
+        code?: string | undefined;
+        message?: string | undefined;
+      }, 401>)>, (ctx: import("hono").Context<import("faire-auth").ContextVars<{
+        session?: {
+          session: Session;
+          user: User;
+        };
+      }>, "/subscription/billing-portal" | "/subscription/cancel" | "/subscription/list" | "/subscription/restore" | "/subscription/upgrade", {
+        out: {
+          json: {
+            referenceId?: string;
+          };
+          query: {
+            referenceId?: string;
+          };
+        };
+      }>, next: import("hono").Next) => Promise<void | (Response & import("hono").TypedResponse<{
+        success: false;
+      }, 401, "json">) | (Response & import("hono").TypedResponse<{
+        success: false;
+      }, 400, "json">)>];
+      request: {
+        body: {
+          description?: string;
+          content: {
+            "application/json": {
+              schema: z.ZodObject<{
+                referenceId: z.ZodOptional<z.ZodString>;
+                subscriptionId: z.ZodOptional<z.ZodString>;
+              }, z.core.$strip>;
+            };
+          };
+          required: true;
+        };
+      };
+      responses: {
+        200: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.ZodType<Stripe.Subscription, unknown, z.core.$ZodTypeInternals<Stripe.Subscription, unknown>>;
+            };
+          };
+        };
+      } & {
+        400: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.core.$ZodBranded<z.ZodObject<{
+                success: z.ZodLiteral<false>;
+                code: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+              }, z.core.$strip>, "error", "out">;
+            };
+          };
+        };
+      } & {
+        401: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.core.$ZodBranded<z.ZodObject<{
+                success: z.ZodLiteral<false>;
+                code: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+              }, z.core.$strip>, "error", "out">;
+            };
+          };
+        };
+      };
+    }>;
+    /**
+     * ### Endpoint
+     *
+     * GET `/subscription/list`
+     *
+     * ### API Methods
+     *
+     * **server:**
+     * `auth.api.listActiveSubscriptions`
+     *
+     * **client:**
+     * `authClient.subscription.list`
+     *
+     * @see [Read our docs to learn more.](https://faire-auth.com/docs/plugins/stripe#api-method-subscription-list)
+     */
+    readonly listActiveSubscriptions: import("faire-auth").AuthEndpoint<{
+      getRoutingPath: () => "/subscription/list";
+      operationId: "listActiveSubscriptions";
+      method: "get";
+      path: "/subscription/list";
+      middleware: [(ctx: import("hono").Context<import("faire-auth").ContextVars<object & {
+        session: {
+          session: Session;
+          user: User;
+        };
+      }>, string, {}>, next: import("hono").Next) => Promise<void | (Response & import("hono").TypedResponse<{
+        success: false;
+        code?: string | undefined;
+        message?: string | undefined;
+      }, 401>)>, (ctx: import("hono").Context<import("faire-auth").ContextVars<{
+        session?: {
+          session: Session;
+          user: User;
+        };
+      }>, "/subscription/billing-portal" | "/subscription/cancel" | "/subscription/list" | "/subscription/restore" | "/subscription/upgrade", {
+        out: {
+          json: {
+            referenceId?: string;
+          };
+          query: {
+            referenceId?: string;
+          };
+        };
+      }>, next: import("hono").Next) => Promise<void | (Response & import("hono").TypedResponse<{
+        success: false;
+      }, 401, "json">) | (Response & import("hono").TypedResponse<{
+        success: false;
+      }, 400, "json">)>];
+      request: {
+        query: z.ZodObject<{
+          referenceId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+      };
+      responses: {
+        200: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.ZodType<Subscription[], unknown, z.core.$ZodTypeInternals<Subscription[], unknown>>;
+            };
+          };
+        };
+      } & {
+        400: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.core.$ZodBranded<z.ZodObject<{
+                success: z.ZodLiteral<false>;
+                code: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+              }, z.core.$strip>, "error", "out">;
+            };
+          };
+        };
+      } & {
+        401: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.core.$ZodBranded<z.ZodObject<{
+                success: z.ZodLiteral<false>;
+                code: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+              }, z.core.$strip>, "error", "out">;
+            };
+          };
+        };
+      };
+    }>;
+    readonly subscriptionSuccess: import("faire-auth").AuthEndpoint<{
+      getRoutingPath: () => "/subscription/success";
+      operationId: "subscriptionSuccess";
+      method: "get";
+      path: "/subscription/success";
+      middleware: [(ctx: import("hono").Context<import("faire-auth").ContextVars<object>, string, {}>, next: import("hono").Next) => Promise<void | Response>];
+      request: {
+        query: z.ZodObject<{
+          callbackURL: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodTransform<string | undefined, string | undefined>, z.ZodOptional<z.ZodURL>>, z.ZodTransform<string | undefined, string | undefined>>>;
+          subscriptionId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+      };
+      responses: {
+        200: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            };
+          };
+        };
+      } & {
+        302: {
+          description: string;
+        };
+      };
+    }>;
+    readonly createBillingPortal: import("faire-auth").AuthEndpoint<{
+      getRoutingPath: () => "/subscription/billing-portal";
+      operationId: "createBillingPortal";
+      method: "post";
+      path: "/subscription/billing-portal";
+      middleware: [(ctx: import("hono").Context<import("faire-auth").ContextVars<{
+        session: {
+          user: {
+            stripeCustomerId?: string;
+          };
+        };
+      } & {
+        session: {
+          session: Session;
+          user: User;
+        };
+      }>, string, {}>, next: import("hono").Next) => Promise<void | (Response & import("hono").TypedResponse<{
+        success: false;
+        code?: string | undefined;
+        message?: string | undefined;
+      }, 401>)>, (ctx: import("hono").Context<import("faire-auth").ContextVars<object>, string, {}>, next: import("hono").Next) => Promise<void | Response>, (ctx: import("hono").Context<import("faire-auth").ContextVars<{
+        session?: {
+          session: Session;
+          user: User;
+        };
+      }>, "/subscription/billing-portal" | "/subscription/cancel" | "/subscription/list" | "/subscription/restore" | "/subscription/upgrade", {
+        out: {
+          json: {
+            referenceId?: string;
+          };
+          query: {
+            referenceId?: string;
+          };
+        };
+      }>, next: import("hono").Next) => Promise<void | (Response & import("hono").TypedResponse<{
+        success: false;
+      }, 401, "json">) | (Response & import("hono").TypedResponse<{
+        success: false;
+      }, 400, "json">)>];
+      request: {
+        body: {
+          description?: string;
+          content: {
+            "application/json": {
+              schema: z.ZodObject<{
+                locale: z.ZodOptional<z.ZodCustom<Stripe.Checkout.Session.Locale, Stripe.Checkout.Session.Locale>>;
+                referenceId: z.ZodOptional<z.ZodString>;
+                returnUrl: z.ZodDefault<z.ZodString>;
+              }, z.core.$strip>;
+            };
+          };
+          required: true;
+        };
+      };
+      responses: {
+        200: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.ZodObject<{
+                url: z.ZodString;
+                redirect: z.ZodLiteral<true>;
+              }, z.core.$strip>;
+            };
+          };
+        };
+      } & {
+        400: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.core.$ZodBranded<z.ZodObject<{
+                success: z.ZodLiteral<false>;
+                code: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+              }, z.core.$strip>, "error", "out">;
+            };
+          };
+        };
+      } & {
+        401: {
+          description: string;
+          content: {
+            "application/json": {
+              schema: z.core.$ZodBranded<z.ZodObject<{
+                success: z.ZodLiteral<false>;
+                code: z.ZodOptional<z.ZodString>;
+                message: z.ZodOptional<z.ZodString>;
+              }, z.core.$strip>, "error", "out">;
+            };
+          };
+        };
+      };
+    }>;
+  } : {});
+  init(ctx: import("@faire-auth/core/types").AuthContext<import("faire-auth").ContextVars<any>, import("@faire-auth/core/types").FaireAuthOptions<import("faire-auth").ContextVars<any>>>): {
+    options: {
+      databaseHooks: {
+        user: {
+          create: {
+            after(user: {
+              [x: string]: unknown;
+              id: string;
+              createdAt: Date;
+              updatedAt: Date;
+              email: string;
+              emailVerified: boolean;
+              name?: string;
+              image?: string | null;
+            }, ctx: import("hono").Context<any, any, {}> | undefined): Promise<void>;
+          };
+        };
+      };
+    };
+  };
+  schema: {};
+};
+type StripePlugin<O extends StripeOptions> = ReturnType<typeof stripe<O>>;
+export { Subscription as i, stripe as n, StripePlan as r, StripePlugin as t };