import { C as Subscription, E as getSchema, S as Session, T as User, _ as PaystackPlan, a as getMetadataBoolean, b as PaystackTransaction, c as hasPaystackMetadata, d as AnyPaystackOptions, f as ChargeRecurringSubscriptionInput, g as PaystackOptions, h as PaystackInitializeResult, i as createRenewalMetadata, l as parsePaystackMetadata, m as PaystackClientLike, n as createCheckoutMetadata, o as getMetadataNumber, p as ChargeRecurringSubscriptionResult, r as createProrationMetadata, s as getMetadataString, t as PaystackMetadata, u as stringifyPaystackMetadata, v as PaystackProduct, w as SubscriptionOptions, x as PaystackTransactionResponse, y as PaystackSyncResult } from "./metadata-BQrgMYcE.mjs";
import { AuthContext, BetterAuthPlugin, GenericEndpointContext, MiddlewareInputContext, MiddlewareOptions, StrictEndpoint, defineErrorCodes } from "better-auth";
import { z } from "zod";

//#region src/routes.d.ts
declare const paystackWebhook: <P extends string = "/webhook">(options: AnyPaystackOptions, path?: P) => StrictEndpoint<P, {
  method: "POST";
  metadata: {
    openapi: {
      operationId: string;
    };
    scope: "server";
  };
  cloneRequest: true;
  disableBody: true;
}, {
  received: boolean;
}>;
declare const initializeTransaction: <P extends string = "/initialize-transaction">(options: AnyPaystackOptions, path?: P) => StrictEndpoint<P, {
  method: "POST";
  body: z.ZodObject<{
    plan: z.ZodOptional<z.ZodString>;
    product: z.ZodOptional<z.ZodString>;
    amount: z.ZodOptional<z.ZodNumber>;
    currency: z.ZodOptional<z.ZodString>;
    email: z.ZodOptional<z.ZodString>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    referenceId: z.ZodOptional<z.ZodString>;
    callbackURL: z.ZodOptional<z.ZodString>;
    quantity: z.ZodOptional<z.ZodNumber>;
    scheduleAtPeriodEnd: z.ZodOptional<z.ZodBoolean>;
    cancelAtPeriodEnd: z.ZodOptional<z.ZodBoolean>;
    prorateAndCharge: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>;
  use: (((getValue: (ctx: GenericEndpointContext) => string | string[]) => (inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<void>) | ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<unknown>))[];
}, PaystackInitializeResult | undefined>;
declare const createSubscription: <P extends string = "/create-subscription">(options: AnyPaystackOptions, path?: P) => StrictEndpoint<P, {
  method: "POST";
  body: z.ZodObject<{
    plan: z.ZodOptional<z.ZodString>;
    product: z.ZodOptional<z.ZodString>;
    amount: z.ZodOptional<z.ZodNumber>;
    currency: z.ZodOptional<z.ZodString>;
    email: z.ZodOptional<z.ZodString>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    referenceId: z.ZodOptional<z.ZodString>;
    callbackURL: z.ZodOptional<z.ZodString>;
    quantity: z.ZodOptional<z.ZodNumber>;
    scheduleAtPeriodEnd: z.ZodOptional<z.ZodBoolean>;
    cancelAtPeriodEnd: z.ZodOptional<z.ZodBoolean>;
    prorateAndCharge: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>;
  use: (((getValue: (ctx: GenericEndpointContext) => string | string[]) => (inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<void>) | ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<unknown>))[];
}, PaystackInitializeResult | undefined>;
declare const upgradeSubscription: <P extends string = "/upgrade-subscription">(options: AnyPaystackOptions, path?: P) => StrictEndpoint<P, {
  method: "POST";
  body: z.ZodObject<{
    plan: z.ZodOptional<z.ZodString>;
    product: z.ZodOptional<z.ZodString>;
    amount: z.ZodOptional<z.ZodNumber>;
    currency: z.ZodOptional<z.ZodString>;
    email: z.ZodOptional<z.ZodString>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    referenceId: z.ZodOptional<z.ZodString>;
    callbackURL: z.ZodOptional<z.ZodString>;
    quantity: z.ZodOptional<z.ZodNumber>;
    scheduleAtPeriodEnd: z.ZodOptional<z.ZodBoolean>;
    cancelAtPeriodEnd: z.ZodOptional<z.ZodBoolean>;
    prorateAndCharge: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>;
  use: (((getValue: (ctx: GenericEndpointContext) => string | string[]) => (inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<void>) | ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<unknown>))[];
}, PaystackInitializeResult | undefined>;
declare const cancelSubscription: <P extends string = "/cancel-subscription">(options: AnyPaystackOptions, path?: P) => StrictEndpoint<P, {
  method: "POST";
  body: z.ZodObject<{
    referenceId: z.ZodOptional<z.ZodString>;
    subscriptionCode: z.ZodString;
    emailToken: z.ZodOptional<z.ZodString>;
    atPeriodEnd: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>;
  use: (((getValue: (ctx: GenericEndpointContext) => string | string[]) => (inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<void>) | ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<unknown>))[];
}, {
  status: string;
}>;
declare const restoreSubscription: <P extends string = "/restore-subscription">(options: AnyPaystackOptions, path?: P) => StrictEndpoint<P, {
  method: "POST";
  body: z.ZodObject<{
    referenceId: z.ZodOptional<z.ZodString>;
    subscriptionCode: z.ZodString;
    emailToken: z.ZodOptional<z.ZodString>;
    atPeriodEnd: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>;
  use: (((getValue: (ctx: GenericEndpointContext) => string | string[]) => (inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<void>) | ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<unknown>))[];
}, {
  status: string;
}>;
declare const verifyTransaction: <P extends string = "/verify-transaction">(options: AnyPaystackOptions, path?: P) => StrictEndpoint<P, {
  method: "POST";
  body: z.ZodObject<{
    reference: z.ZodString;
  }, z.core.$strip>;
  use: (((getValue: (ctx: GenericEndpointContext) => string | string[]) => (inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<void>) | ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<unknown>))[];
}, {
  status: string;
  reference: string;
  data: {
    id: number;
    domain: string;
    status: string;
    reference: string;
    receipt_number: string | null;
    amount: number;
    message: string | null;
    gateway_response: string;
    channel: string;
    currency: string;
    ip_address: string | null;
    metadata: (string | Record<string, never> | number) | null;
    log: {
      start_time: number;
      time_spent: number;
      attempts: number;
      errors: number;
      success: boolean;
      mobile: boolean;
      input: unknown[];
      history: {
        type: string;
        message: string;
        time: number;
      }[];
    } | null;
    fees: number | null;
    fees_split: unknown;
    authorization: {
      authorization_code?: string;
      bin?: string | null;
      last4?: string;
      exp_month?: string;
      exp_year?: string;
      channel?: string;
      card_type?: string;
      bank?: string;
      country_code?: string;
      brand?: string;
      reusable?: boolean;
      signature?: string;
      account_name?: string | null;
      receiver_bank_account_number?: string | null;
      receiver_bank?: string | null;
    };
    customer: {
      id: number;
      first_name: string | null;
      last_name: string | null;
      email: string;
      customer_code: string;
      phone: string | null;
      metadata: Record<string, never> | null;
      risk_action: string;
      international_format_phone?: string | null;
    };
    plan: (string | Record<string, never>) | null;
    split: Record<string, never> | null;
    order_id: unknown;
    paidAt: string | null;
    createdAt: string;
    requested_amount: number;
    pos_transaction_data: unknown;
    source: unknown;
    fees_breakdown: unknown;
    connect: unknown;
    transaction_date: string;
    plan_object: {
      id?: number;
      name?: string;
      plan_code?: string;
      description?: unknown;
      amount?: number;
      interval?: string;
      send_invoices?: boolean;
      send_sms?: boolean;
      currency?: string;
    };
    subaccount: Record<string, never> | null;
  };
}>;
declare const listSubscriptions: <P extends string = "/list-subscriptions">(options: AnyPaystackOptions, path?: P) => StrictEndpoint<P, {
  method: "GET";
  query: z.ZodObject<{
    referenceId: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>;
  use: (((getValue: (ctx: GenericEndpointContext) => string | string[]) => (inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<void>) | ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<unknown>))[];
}, {
  subscriptions: Subscription[];
}>;
declare const listTransactions: <P extends string = "/list-transactions">(options: AnyPaystackOptions, path?: P) => StrictEndpoint<P, {
  method: "GET";
  query: z.ZodObject<{
    referenceId: z.ZodOptional<z.ZodString>;
  }, z.core.$strip>;
  use: (((getValue: (ctx: GenericEndpointContext) => string | string[]) => (inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<void>) | ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<unknown>))[];
}, {
  transactions: PaystackTransaction[];
}>;
declare const disablePaystackSubscription: <P extends string = "/disable-subscription">(options: AnyPaystackOptions, path?: P) => StrictEndpoint<P, {
  method: "POST";
  body: z.ZodObject<{
    referenceId: z.ZodOptional<z.ZodString>;
    subscriptionCode: z.ZodString;
    emailToken: z.ZodOptional<z.ZodString>;
    atPeriodEnd: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>;
  use: (((getValue: (ctx: GenericEndpointContext) => string | string[]) => (inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<void>) | ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<unknown>))[];
}, {
  status: string;
}>;
declare const enablePaystackSubscription: <P extends string = "/enable-subscription">(options: AnyPaystackOptions, path?: P) => StrictEndpoint<P, {
  method: "POST";
  body: z.ZodObject<{
    referenceId: z.ZodOptional<z.ZodString>;
    subscriptionCode: z.ZodString;
    emailToken: z.ZodOptional<z.ZodString>;
    atPeriodEnd: z.ZodOptional<z.ZodBoolean>;
  }, z.core.$strip>;
  use: (((getValue: (ctx: GenericEndpointContext) => string | string[]) => (inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<void>) | ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<unknown>))[];
}, {
  status: string;
}>;
declare const getSubscriptionManageLink: <P extends string = "/subscription-manage-link">(options: AnyPaystackOptions, path?: P) => StrictEndpoint<P, {
  method: "GET";
  query: z.ZodObject<{
    subscriptionCode: z.ZodString;
  }, z.core.$strip>;
  use: (((getValue: (ctx: GenericEndpointContext) => string | string[]) => (inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<void>) | ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<unknown>))[];
}, {
  link: string | null;
}>;
declare const listProducts: <P extends string = "/list-products">(_options: AnyPaystackOptions, path?: P) => StrictEndpoint<P, {
  method: "GET";
  metadata: {
    openapi: {
      operationId: string;
    };
  };
}, {
  products: PaystackProduct[];
}>;
declare const listPlans: <P extends string = "/list-plans">(_options: AnyPaystackOptions, path?: P) => StrictEndpoint<P, {
  method: "GET";
  metadata: {
    scope: "server";
  };
  use: ((inputContext: MiddlewareInputContext<MiddlewareOptions>) => Promise<{
    session: {
      session: Record<string, unknown> & {
        id: string;
        createdAt: Date;
        updatedAt: Date;
        userId: string;
        expiresAt: Date;
        token: string;
        ipAddress?: string | null | undefined;
        userAgent?: string | null | undefined;
      };
      user: Record<string, unknown> & {
        id: string;
        createdAt: Date;
        updatedAt: Date;
        email: string;
        emailVerified: boolean;
        name: string;
        image?: string | null | undefined;
      };
    };
  }>)[];
}, {
  plans: PaystackPlan[];
}>;
declare const getConfig: <P extends string = "/get-config">(options: AnyPaystackOptions, path?: P) => StrictEndpoint<P, {
  method: "GET";
  metadata: {
    openapi: {
      operationId: string;
    };
  };
}, {
  plans: PaystackPlan[];
  products: PaystackProduct[];
}>;
//#endregion
//#region src/version.d.ts
declare const PACKAGE_VERSION = "3.0.0";
//#endregion
//#region src/operations.d.ts
declare function syncPaystackProducts(ctx: GenericEndpointContext, options: AnyPaystackOptions): Promise<PaystackSyncResult>;
declare function syncPaystackPlans(ctx: GenericEndpointContext, options: AnyPaystackOptions): Promise<PaystackSyncResult>;
declare function chargeSubscriptionRenewal(ctx: GenericEndpointContext, options: AnyPaystackOptions, input: ChargeRecurringSubscriptionInput): Promise<ChargeRecurringSubscriptionResult>;
//#endregion
//#region src/reconciliation.d.ts
type PaystackReconciliationSource = "webhook" | "queue" | "admin" | "server" | "browser";
interface ReconcilePaystackTransactionInput {
  reference: string;
  source?: PaystackReconciliationSource;
  referenceId?: string;
  actor?: {
    user: User;
    session: Session;
  };
  throwOnError?: boolean;
}
interface PaystackReconciliationError {
  code: string;
  message: string;
  status?: number;
}
interface PaystackReconciliationSummary {
  transaction: {
    found: boolean;
    updated: boolean;
    referenceId?: string;
    previousStatus?: string;
    status?: string;
  };
  subscription: {
    found: boolean;
    updated: boolean;
    id?: string;
    status?: string;
    prorationApplied: boolean;
  };
  customer: {
    saved: boolean;
    referenceId?: string;
    customerCode?: string;
    model?: "user" | "organization";
  };
  product: {
    synced: boolean;
    name?: string;
  };
}
interface ReconcilePaystackTransactionSuccess extends PaystackReconciliationSummary {
  ok: true;
  source: PaystackReconciliationSource;
  status: string;
  reference: string;
  data: PaystackTransactionResponse;
  error?: undefined;
}
interface ReconcilePaystackTransactionFailure extends PaystackReconciliationSummary {
  ok: false;
  source: PaystackReconciliationSource;
  status: string;
  reference: string;
  data: PaystackTransactionResponse | null;
  error: PaystackReconciliationError;
}
type ReconcilePaystackTransactionResult = ReconcilePaystackTransactionSuccess | ReconcilePaystackTransactionFailure;
declare function reconcilePaystackTransaction(ctx: GenericEndpointContext, options: AnyPaystackOptions, input: ReconcilePaystackTransactionInput): Promise<ReconcilePaystackTransactionResult>;
//#endregion
//#region src/index.d.ts
declare module "better-auth" {
  interface BetterAuthPluginRegistry<AuthOptions, Options> {
    paystack: {
      creator: typeof paystack;
    };
  }
}
declare const INTERNAL_ERROR_CODES: ReturnType<typeof defineErrorCodes>;
type BetterAuthEndpoint = NonNullable<BetterAuthPlugin["endpoints"]>[string];
interface PaystackPluginEndpoints extends Record<string, BetterAuthEndpoint> {
  initializeTransaction: ReturnType<typeof initializeTransaction>;
  verifyTransaction: ReturnType<typeof verifyTransaction>;
  listSubscriptions: ReturnType<typeof listSubscriptions>;
  paystackWebhook: ReturnType<typeof paystackWebhook>;
  listTransactions: ReturnType<typeof listTransactions>;
  getConfig: ReturnType<typeof getConfig>;
  disableSubscription: ReturnType<typeof disablePaystackSubscription>;
  enableSubscription: ReturnType<typeof enablePaystackSubscription>;
  getSubscriptionManageLink: ReturnType<typeof getSubscriptionManageLink>;
  subscriptionManageLink: ReturnType<typeof getSubscriptionManageLink>;
  createSubscription: ReturnType<typeof createSubscription>;
  upgradeSubscription: ReturnType<typeof upgradeSubscription>;
  cancelSubscription: ReturnType<typeof cancelSubscription>;
  restoreSubscription: ReturnType<typeof restoreSubscription>;
  listProducts: ReturnType<typeof listProducts>;
  listPlans: ReturnType<typeof listPlans>;
}
type PaystackHookHandler = (...args: unknown[]) => unknown;
interface PaystackPluginInitResult {
  options: {
    databaseHooks: Record<string, unknown> & {
      organization: {
        create: {
          after: PaystackHookHandler;
        };
      };
    };
  };
}
type PaystackPluginInit = ((ctx: AuthContext) => PaystackPluginInitResult) & NonNullable<BetterAuthPlugin["init"]>;
type PaystackPluginInstance<O extends AnyPaystackOptions> = Omit<BetterAuthPlugin, "id" | "version" | "endpoints" | "schema" | "init" | "$ERROR_CODES" | "options"> & {
  id: "paystack";
  version: typeof PACKAGE_VERSION;
  endpoints: PaystackPluginEndpoints;
  schema: ReturnType<typeof getSchema>;
  init: PaystackPluginInit;
  $ERROR_CODES: typeof INTERNAL_ERROR_CODES;
  options: NoInfer<O>;
};
declare const createPaystackPlugin: <TPaystackClient extends PaystackClientLike = PaystackClientLike, O extends PaystackOptions<TPaystackClient> = PaystackOptions<TPaystackClient>>(options: O) => PaystackPluginInstance<O>;
declare const paystack: typeof createPaystackPlugin;
type PaystackPlugin<TPaystackClient extends PaystackClientLike = PaystackClientLike, O extends PaystackOptions<TPaystackClient> = PaystackOptions<TPaystackClient>> = ReturnType<typeof paystack<TPaystackClient, O>>;
//#endregion
export { type ChargeRecurringSubscriptionResult, type PaystackClientLike, type PaystackInitializeResult, type PaystackMetadata, type PaystackOptions, type PaystackPlan, PaystackPlugin, type PaystackProduct, type PaystackReconciliationError, type PaystackReconciliationSource, type PaystackReconciliationSummary, type PaystackSyncResult, type PaystackTransactionResponse, type ReconcilePaystackTransactionFailure, type ReconcilePaystackTransactionInput, type ReconcilePaystackTransactionResult, type ReconcilePaystackTransactionSuccess, type Subscription, type SubscriptionOptions, chargeSubscriptionRenewal, createCheckoutMetadata, createProrationMetadata, createRenewalMetadata, getMetadataBoolean, getMetadataNumber, getMetadataString, hasPaystackMetadata, parsePaystackMetadata, paystack, reconcilePaystackTransaction, stringifyPaystackMetadata, syncPaystackPlans, syncPaystackProducts };
//# sourceMappingURL=index.d.mts.map