> ## Documentation Index
> Fetch the complete documentation index at: https://better-auth-razorpay.amankushwaha.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Types

> TypeScript type signatures for plugin options, subscription configuration, plans, and verification responses.

The plugin exports TypeScript types from the server entry point. Import them when you need to type your configuration, callbacks, or custom utilities.

## Importing types

```ts theme={null}
import {
  RazorpayPluginOptions,
  SubscriptionOptions,
  RazorpayPlan,
  Subscription,
  VerifyRazorpayPaymentResponse,
  RazorpayPaymentVerificationStatus,
} from "@amank-root/better-auth-razorpay";
```

## RazorpayPluginOptions

Top-level options passed to the `razorpay()` plugin function.

```ts theme={null}
type RazorpayPluginOptions = {
  razorpayClient?: Razorpay;
  keyId?: string;
  keySecret?: string;
  defaultCurrency?: string; // default "INR"
  requireSession?: boolean; // default true
  razorpayWebhookSecret?: string;
  createCustomerOnSignUp?: boolean; // default false
  onCustomerCreate?: ({
    razorpayCustomer,
    user,
  }: {
    razorpayCustomer: any;
    user: any;
  }, ctx: any) => Promise<void> | void;
  getCustomerCreateParams?: (
    user: any,
    ctx: any
  ) => Promise<Partial<any>>;
  subscription?:
    | { enabled: false }
    | { enabled: true } & SubscriptionOptions;
  organization?: {
    enabled: true;
    getCustomerCreateParams?: (organization: any, ctx: any) => Promise<Partial<any>>;
    onCustomerCreate?: ({
      razorpayCustomer,
      organization,
    }: {
      razorpayCustomer: any;
      organization: any;
    }, ctx: any) => Promise<void> | void;
  };
  onEvent?: (event: any) => Promise<void> | void;
  onPaymentAuthorized?: ({
    event,
    payment,
  }: {
    event: any;
    payment: any;
  }) => Promise<void> | void;
  onPaymentCaptured?: ({
    event,
    payment,
  }: {
    event: any;
    payment: any;
  }) => Promise<void> | void;
  onPaymentFailed?: ({
    event,
    payment,
  }: {
    event: any;
    payment: any;
  }) => Promise<void> | void;
  onOrderPaid?: ({
    event,
    order,
  }: {
    event: any;
    order: any;
  }) => Promise<void> | void;
  onRefundCreated?: ({
    event,
    refund,
  }: {
    event: any;
    refund: any;
  }) => Promise<void> | void;
  onRefundProcessed?: ({
    event,
    refund,
  }: {
    event: any;
    refund: any;
  }) => Promise<void> | void;
  onRefundFailed?: ({
    event,
    refund,
  }: {
    event: any;
    refund: any;
  }) => Promise<void> | void;
  onInvoicePaid?: ({
    event,
    invoice,
  }: {
    event: any;
    invoice: any;
  }) => Promise<void> | void;
  onInvoicePartiallyPaid?: ({
    event,
    invoice,
  }: {
    event: any;
    invoice: any;
  }) => Promise<void> | void;
  onInvoiceExpired?: ({
    event,
    invoice,
  }: {
    event: any;
    invoice: any;
  }) => Promise<void> | void;
  schema?: any; // Better Auth schema overrides
};
```

## SubscriptionOptions

Configuration for the subscription feature, nested inside `subscription` when `enabled: true`.

```ts theme={null}
type SubscriptionOptions = {
  plans: RazorpayPlan[] | (() => RazorpayPlan[] | Promise<RazorpayPlan[]>);
  requireEmailVerification?: boolean; // default false
  onSubscriptionActivated?: ({
    event,
    razorpaySubscription,
    subscription,
    plan,
  }: {
    event: any;
    razorpaySubscription: any;
    subscription: Subscription;
    plan: RazorpayPlan;
  }) => Promise<void> | void;
  onSubscriptionCharged?: ({
    event,
    razorpaySubscription,
    subscription,
  }: {
    event: any;
    razorpaySubscription: any;
    subscription: Subscription;
  }) => Promise<void> | void;
  onSubscriptionAuthenticated?: ({
    event,
    razorpaySubscription,
    subscription,
  }: {
    event: any;
    razorpaySubscription: any;
    subscription: Subscription;
  }) => Promise<void> | void;
  onSubscriptionCancelled?: ({
    event,
    razorpaySubscription,
    subscription,
  }: {
    event: any;
    razorpaySubscription: any;
    subscription: Subscription;
  }) => Promise<void> | void;
  onSubscriptionPaused?: ({
    event,
    razorpaySubscription,
    subscription,
  }: {
    event: any;
    razorpaySubscription: any;
    subscription: Subscription;
  }) => Promise<void> | void;
  onSubscriptionResumed?: ({
    event,
    razorpaySubscription,
    subscription,
  }: {
    event: any;
    razorpaySubscription: any;
    subscription: Subscription;
  }) => Promise<void> | void;
  onSubscriptionHalted?: ({
    event,
    razorpaySubscription,
    subscription,
  }: {
    event: any;
    razorpaySubscription: any;
    subscription: Subscription;
  }) => Promise<void> | void;
  onSubscriptionPending?: ({
    event,
    razorpaySubscription,
    subscription,
  }: {
    event: any;
    razorpaySubscription: any;
    subscription: Subscription;
  }) => Promise<void> | void;
  onSubscriptionCompleted?: ({
    event,
    razorpaySubscription,
    subscription,
  }: {
    event: any;
    razorpaySubscription: any;
    subscription: Subscription;
  }) => Promise<void> | void;
  onSubscriptionUpdated?: ({
    event,
    razorpaySubscription,
    subscription,
  }: {
    event: any;
    razorpaySubscription: any;
    subscription: Subscription;
  }) => Promise<void> | void;
  onSubscriptionRenewed?: ({
    event,
    razorpaySubscription,
    subscription,
  }: {
    event: any;
    razorpaySubscription: any;
    subscription: Subscription;
  }) => Promise<void> | void;
  authorizeReference?: ({
    user,
    session,
    referenceId,
    action,
  }: {
    user: any;
    session: any;
    referenceId: string;
    action:
      | "upgrade-subscription"
      | "list-subscription"
      | "cancel-subscription"
      | "pause-subscription"
      | "resume-subscription"
      | "update-subscription"
      | "restore-subscription"
      | "get-subscription";
  }, ctx: any) => Promise<boolean> | boolean;
  getSubscriptionCreateParams?: ({
    user,
    session,
    plan,
  }: {
    user: any;
    session: any;
    plan: RazorpayPlan;
  }, ctx: any) => Promise<Partial<any>>;
};
```

## RazorpayPlan

A plan definition that maps a friendly name to a Razorpay plan ID.

```ts theme={null}
type RazorpayPlan = {
  planId: string; // Razorpay plan_ id
  annualPlanId?: string;
  name: string; // matched case-insensitively, stored lowercased
  limits?: Record<string, unknown>; // e.g. { projects: 10, storage: 50 }
  group?: string;
  totalCount?: number; // billing cycles; default 0
  quantity?: number; // seat count; default 1
  freeTrial?: {
    days: number;
    onTrialStart?: (subscription: Subscription) => void;
    onTrialEnd?: ({ subscription }: { subscription: Subscription }, ctx: any) => void;
    onTrialExpired?: (subscription: Subscription, ctx: any) => void;
  };
};
```

## Subscription

The local subscription row stored in the plugin-managed `subscription` table.

```ts theme={null}
type Subscription = {
  id: string;
  plan: string;
  referenceId: string;
  razorpayCustomerId: string;
  razorpaySubscriptionId: string;
  razorpayPlanId: string;
  status:
    | "created"
    | "authenticated"
    | "active"
    | "pending"
    | "halted"
    | "cancelled"
    | "completed"
    | "expired"
    | "paused";
  currentStart?: Date;
  currentEnd?: Date;
  endedAt?: Date;
  quantity: number; // default 1
  totalCount: number;
  paidCount: number; // default 0
  remainingCount: number;
  cancelledAt?: Date;
  pausedAt?: Date;
  shortUrl?: string;
  cancelAtCycleEnd: boolean; // default false
  groupId?: string;
  billingPeriod: "monthly" | "yearly";
  trialStart?: Date;
  trialEnd?: Date;
  metadata?: string; // JSON string
  renewedAt?: Date;
};
```

## VerifyRazorpayPaymentResponse

Return type of the `verifyRazorpayPayment` client/server endpoint.

```ts theme={null}
type VerifyRazorpayPaymentResponse = {
  valid: boolean;
  paymentStatus: string;
  amount: number;
  currency: string;
  orderId: string | null;
  reason?:
    | "invalid_signature"
    | "order_mismatch"
    | "amount_mismatch"
    | "payment_not_captured";
};
```

## RazorpayPaymentVerificationStatus

Return type of the standalone `verifyRazorpayPaymentStatus` utility.

```ts theme={null}
type RazorpayPaymentVerificationStatus = {
  valid: boolean;
  paymentStatus: string;
  amount: number;
  currency: string;
  orderId: string | null;
  reason?:
    | "invalid_signature"
    | "order_mismatch"
    | "amount_mismatch"
    | "payment_not_captured";
};
```

## authorizeReference parameters

When you implement `authorizeReference` for organization subscriptions, the function receives these arguments:

```ts theme={null}
({
  user,
  session,
  referenceId,
  action,
}: {
  user: any;
  session: any;
  referenceId: string;
  action:
    | "upgrade-subscription"
    | "list-subscription"
    | "cancel-subscription"
    | "pause-subscription"
    | "resume-subscription"
    | "update-subscription"
    | "restore-subscription"
    | "get-subscription";
}, ctx: any) => Promise<boolean> | boolean
```

Return `true` to allow the action, `false` to deny it. Required for organization subscriptions; omitting it raises `AUTHORIZE_REFERENCE_REQUIRED`.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.