@relipay/shared-types 0.1.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,1378 @@
+/**
+ * @relipay/shared-types
+ *
+ * Zod schemas + TypeScript types shared between the API and the SDKs.
+ * Anything serialized over the wire lives here — never duplicate a shape.
+ */
+import { z } from 'zod';
+/**
+ * The error envelope every ReliPay API response uses on failure.
+ *
+ * @example
+ * ```ts
+ * { code: 'PLAN_NOT_FOUND', message: 'Plan "pro" not found.', fix: 'Run `relipay plans list`.' }
+ * ```
+ */
+export declare const RelipayErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    /** Concrete remediation a human or AI agent can act on. */
+    fix: z.ZodOptional<z.ZodString>;
+    /** Documentation URL for this error code. */
+    docs: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    message: string;
+    fix?: string | undefined;
+    docs?: string | undefined;
+}, {
+    code: string;
+    message: string;
+    fix?: string | undefined;
+    docs?: string | undefined;
+}>;
+export type RelipayError = z.infer<typeof RelipayErrorSchema>;
+export declare const ApiResponseSchema: <T extends z.ZodTypeAny>(data: T) => z.ZodDiscriminatedUnion<"success", [z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: T;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    success: z.ZodLiteral<true>;
+    data: T;
+}>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<{
+    success: z.ZodLiteral<true>;
+    data: T;
+}> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never>, z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        /** Concrete remediation a human or AI agent can act on. */
+        fix: z.ZodOptional<z.ZodString>;
+        /** Documentation URL for this error code. */
+        docs: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+        fix?: string | undefined;
+        docs?: string | undefined;
+    }, {
+        code: string;
+        message: string;
+        fix?: string | undefined;
+        docs?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: string;
+        message: string;
+        fix?: string | undefined;
+        docs?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: string;
+        message: string;
+        fix?: string | undefined;
+        docs?: string | undefined;
+    };
+}>]>;
+/**
+ * Auth methods this Application exposes. `password` and `magic_link` are
+ * primary methods (the SDK calls them directly). OAuth provider presence is
+ * implicit from `Application.oauthConfig` having that provider as a key —
+ * not duplicated here. Open string to keep the enum from limiting future
+ * additions.
+ */
+export declare const AuthMethodSchema: z.ZodString;
+export type AuthMethod = z.infer<typeof AuthMethodSchema>;
+export declare const AuthConfigSchema: z.ZodObject<{
+    /** Which primary methods are enabled. Empty array = OAuth-only app. */
+    methods: z.ZodArray<z.ZodString, "many">;
+    passwordMinLength: z.ZodDefault<z.ZodNumber>;
+    /** Where to send the user after sign-in / sign-up. */
+    redirectUrls: z.ZodArray<z.ZodString, "many">;
+    /** If true, organisations / teams are enabled for this application. */
+    organizationsEnabled: z.ZodDefault<z.ZodBoolean>;
+    /** If false, public sign-up is blocked and operators must invite end-users. */
+    signupEnabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * End-user two-factor (TOTP) policy for this Application:
+     *   - `off`      — MFA endpoints are refused (`MFA_NOT_ENABLED`).
+     *   - `optional` — end-users may enroll; enrolled users are challenged at
+     *                  sign-in (the default — preserves prior behaviour).
+     *   - `required` — sign-in returns `mfaEnrollmentRequired: true` for users
+     *                  who haven't enrolled yet, so the app can force setup.
+     */
+    mfa: z.ZodDefault<z.ZodEnum<["off", "optional", "required"]>>;
+    /**
+     * If true (default), submitted passwords are checked against the HIBP
+     * Pwned Passwords k-anonymity API at sign-up + password-reset +
+     * password-change time. Operators on offline / restricted networks can
+     * opt out per Application; a deployment-level kill-switch lives at
+     * env `HIBP_BREACH_CHECK_DISABLED=true`.
+     */
+    passwordBreachCheckEnabled: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * WebAuthn / passkey configuration. Both fields are required when
+     * `"passkey"` appears in `methods` — the registration ceremony needs
+     * to bind credentials to a specific Relying Party. `rpId` is the
+     * eTLD+1 the credential is scoped to (e.g. `"acme.example.com"`),
+     * `rpOrigins` is the list of full origins the customer's app will
+     * authenticate from (used to verify `origin` on the client response).
+     */
+    webauthn: z.ZodOptional<z.ZodObject<{
+        rpId: z.ZodString;
+        /** At least one origin required. e.g. `["https://app.acme.example.com"]`. */
+        rpOrigins: z.ZodArray<z.ZodString, "many">;
+        /** Human-readable name shown in the OS passkey UI. Falls back to `rpId`. */
+        rpName: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        rpId: string;
+        rpOrigins: string[];
+        rpName?: string | undefined;
+    }, {
+        rpId: string;
+        rpOrigins: string[];
+        rpName?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    methods: string[];
+    passwordMinLength: number;
+    redirectUrls: string[];
+    organizationsEnabled: boolean;
+    signupEnabled: boolean;
+    mfa: "off" | "optional" | "required";
+    passwordBreachCheckEnabled: boolean;
+    webauthn?: {
+        rpId: string;
+        rpOrigins: string[];
+        rpName?: string | undefined;
+    } | undefined;
+}, {
+    methods: string[];
+    redirectUrls: string[];
+    passwordMinLength?: number | undefined;
+    organizationsEnabled?: boolean | undefined;
+    signupEnabled?: boolean | undefined;
+    mfa?: "off" | "optional" | "required" | undefined;
+    passwordBreachCheckEnabled?: boolean | undefined;
+    webauthn?: {
+        rpId: string;
+        rpOrigins: string[];
+        rpName?: string | undefined;
+    } | undefined;
+}>;
+export type AuthConfig = z.infer<typeof AuthConfigSchema>;
+export declare const BillingProviderSchema: z.ZodEnum<["stripe", "paypal", "razorpay"]>;
+export type BillingProvider = z.infer<typeof BillingProviderSchema>;
+export declare const BillingConfigSchema: z.ZodObject<{
+    provider: z.ZodEnum<["stripe", "paypal", "razorpay"]>;
+    /** Default currency for this application. ISO 4217. */
+    currency: z.ZodDefault<z.ZodString>;
+    /** Provider-specific config — Stripe account id, PayPal merchant id, etc. */
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    provider: "stripe" | "paypal" | "razorpay";
+    currency: string;
+    metadata: Record<string, unknown>;
+}, {
+    provider: "stripe" | "paypal" | "razorpay";
+    currency?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export type BillingConfig = z.infer<typeof BillingConfigSchema>;
+export declare const ApplicationDtoSchema: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.ZodString;
+    name: z.ZodString;
+    slug: z.ZodString;
+    publicKey: z.ZodString;
+    authConfig: z.ZodObject<{
+        /** Which primary methods are enabled. Empty array = OAuth-only app. */
+        methods: z.ZodArray<z.ZodString, "many">;
+        passwordMinLength: z.ZodDefault<z.ZodNumber>;
+        /** Where to send the user after sign-in / sign-up. */
+        redirectUrls: z.ZodArray<z.ZodString, "many">;
+        /** If true, organisations / teams are enabled for this application. */
+        organizationsEnabled: z.ZodDefault<z.ZodBoolean>;
+        /** If false, public sign-up is blocked and operators must invite end-users. */
+        signupEnabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * End-user two-factor (TOTP) policy for this Application:
+         *   - `off`      — MFA endpoints are refused (`MFA_NOT_ENABLED`).
+         *   - `optional` — end-users may enroll; enrolled users are challenged at
+         *                  sign-in (the default — preserves prior behaviour).
+         *   - `required` — sign-in returns `mfaEnrollmentRequired: true` for users
+         *                  who haven't enrolled yet, so the app can force setup.
+         */
+        mfa: z.ZodDefault<z.ZodEnum<["off", "optional", "required"]>>;
+        /**
+         * If true (default), submitted passwords are checked against the HIBP
+         * Pwned Passwords k-anonymity API at sign-up + password-reset +
+         * password-change time. Operators on offline / restricted networks can
+         * opt out per Application; a deployment-level kill-switch lives at
+         * env `HIBP_BREACH_CHECK_DISABLED=true`.
+         */
+        passwordBreachCheckEnabled: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * WebAuthn / passkey configuration. Both fields are required when
+         * `"passkey"` appears in `methods` — the registration ceremony needs
+         * to bind credentials to a specific Relying Party. `rpId` is the
+         * eTLD+1 the credential is scoped to (e.g. `"acme.example.com"`),
+         * `rpOrigins` is the list of full origins the customer's app will
+         * authenticate from (used to verify `origin` on the client response).
+         */
+        webauthn: z.ZodOptional<z.ZodObject<{
+            rpId: z.ZodString;
+            /** At least one origin required. e.g. `["https://app.acme.example.com"]`. */
+            rpOrigins: z.ZodArray<z.ZodString, "many">;
+            /** Human-readable name shown in the OS passkey UI. Falls back to `rpId`. */
+            rpName: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            rpId: string;
+            rpOrigins: string[];
+            rpName?: string | undefined;
+        }, {
+            rpId: string;
+            rpOrigins: string[];
+            rpName?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        methods: string[];
+        passwordMinLength: number;
+        redirectUrls: string[];
+        organizationsEnabled: boolean;
+        signupEnabled: boolean;
+        mfa: "off" | "optional" | "required";
+        passwordBreachCheckEnabled: boolean;
+        webauthn?: {
+            rpId: string;
+            rpOrigins: string[];
+            rpName?: string | undefined;
+        } | undefined;
+    }, {
+        methods: string[];
+        redirectUrls: string[];
+        passwordMinLength?: number | undefined;
+        organizationsEnabled?: boolean | undefined;
+        signupEnabled?: boolean | undefined;
+        mfa?: "off" | "optional" | "required" | undefined;
+        passwordBreachCheckEnabled?: boolean | undefined;
+        webauthn?: {
+            rpId: string;
+            rpOrigins: string[];
+            rpName?: string | undefined;
+        } | undefined;
+    }>;
+    billingConfig: z.ZodObject<{
+        provider: z.ZodEnum<["stripe", "paypal", "razorpay"]>;
+        /** Default currency for this application. ISO 4217. */
+        currency: z.ZodDefault<z.ZodString>;
+        /** Provider-specific config — Stripe account id, PayPal merchant id, etc. */
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "stripe" | "paypal" | "razorpay";
+        currency: string;
+        metadata: Record<string, unknown>;
+    }, {
+        provider: "stripe" | "paypal" | "razorpay";
+        currency?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }>;
+    createdAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    tenantId: string;
+    name: string;
+    slug: string;
+    publicKey: string;
+    authConfig: {
+        methods: string[];
+        passwordMinLength: number;
+        redirectUrls: string[];
+        organizationsEnabled: boolean;
+        signupEnabled: boolean;
+        mfa: "off" | "optional" | "required";
+        passwordBreachCheckEnabled: boolean;
+        webauthn?: {
+            rpId: string;
+            rpOrigins: string[];
+            rpName?: string | undefined;
+        } | undefined;
+    };
+    billingConfig: {
+        provider: "stripe" | "paypal" | "razorpay";
+        currency: string;
+        metadata: Record<string, unknown>;
+    };
+    createdAt: string;
+}, {
+    id: string;
+    tenantId: string;
+    name: string;
+    slug: string;
+    publicKey: string;
+    authConfig: {
+        methods: string[];
+        redirectUrls: string[];
+        passwordMinLength?: number | undefined;
+        organizationsEnabled?: boolean | undefined;
+        signupEnabled?: boolean | undefined;
+        mfa?: "off" | "optional" | "required" | undefined;
+        passwordBreachCheckEnabled?: boolean | undefined;
+        webauthn?: {
+            rpId: string;
+            rpOrigins: string[];
+            rpName?: string | undefined;
+        } | undefined;
+    };
+    billingConfig: {
+        provider: "stripe" | "paypal" | "razorpay";
+        currency?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    };
+    createdAt: string;
+}>;
+export type ApplicationDto = z.infer<typeof ApplicationDtoSchema>;
+export declare const EndUserDtoSchema: z.ZodObject<{
+    id: z.ZodString;
+    applicationId: z.ZodString;
+    email: z.ZodString;
+    emailVerified: z.ZodBoolean;
+    metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    metadata: Record<string, unknown> | null;
+    id: string;
+    createdAt: string;
+    applicationId: string;
+    email: string;
+    emailVerified: boolean;
+}, {
+    metadata: Record<string, unknown> | null;
+    id: string;
+    createdAt: string;
+    applicationId: string;
+    email: string;
+    emailVerified: boolean;
+}>;
+export type EndUserDto = z.infer<typeof EndUserDtoSchema>;
+export declare const ApiKeyDtoSchema: z.ZodObject<{
+    id: z.ZodString;
+    applicationId: z.ZodString;
+    name: z.ZodString;
+    keyPrefix: z.ZodString;
+    scopes: z.ZodArray<z.ZodString, "many">;
+    lastUsedAt: z.ZodNullable<z.ZodString>;
+    expiresAt: z.ZodNullable<z.ZodString>;
+    revokedAt: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    createdAt: string;
+    applicationId: string;
+    keyPrefix: string;
+    scopes: string[];
+    lastUsedAt: string | null;
+    expiresAt: string | null;
+    revokedAt: string | null;
+}, {
+    id: string;
+    name: string;
+    createdAt: string;
+    applicationId: string;
+    keyPrefix: string;
+    scopes: string[];
+    lastUsedAt: string | null;
+    expiresAt: string | null;
+    revokedAt: string | null;
+}>;
+export type ApiKeyDto = z.infer<typeof ApiKeyDtoSchema>;
+export declare const SignUpRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    email: string;
+    password: string;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+export type SignUpRequest = z.infer<typeof SignUpRequestSchema>;
+export declare const SignInRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+}, {
+    email: string;
+    password: string;
+}>;
+export type SignInRequest = z.infer<typeof SignInRequestSchema>;
+/**
+ * Result of a successful primary-factor auth (password sign-in, OAuth
+ * callback, MFA-verify). Includes `mfaRequired: false` as the
+ * discriminator field for `SignInOutcomeDto`.
+ */
+export declare const AuthResultDtoSchema: z.ZodObject<{
+    mfaRequired: z.ZodDefault<z.ZodLiteral<false>>;
+    /**
+     * True when the Application's MFA policy is `required` but this user has not
+     * enrolled yet. The session is still issued; the app should route the user
+     * to MFA setup before granting sensitive access.
+     */
+    mfaEnrollmentRequired: z.ZodOptional<z.ZodBoolean>;
+    endUser: z.ZodObject<{
+        id: z.ZodString;
+        applicationId: z.ZodString;
+        email: z.ZodString;
+        emailVerified: z.ZodBoolean;
+        metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        createdAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        email: string;
+        emailVerified: boolean;
+    }, {
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        email: string;
+        emailVerified: boolean;
+    }>;
+    /** Short-lived access JWT. Pass via X-Relipay-User-Token. */
+    accessToken: z.ZodString;
+    accessTokenExpiresAt: z.ZodString;
+    /** Long-lived refresh token. Use to mint new access tokens via auth.refresh(). */
+    refreshToken: z.ZodString;
+    refreshTokenExpiresAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    mfaRequired: false;
+    endUser: {
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        email: string;
+        emailVerified: boolean;
+    };
+    accessToken: string;
+    accessTokenExpiresAt: string;
+    refreshToken: string;
+    refreshTokenExpiresAt: string;
+    mfaEnrollmentRequired?: boolean | undefined;
+}, {
+    endUser: {
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        email: string;
+        emailVerified: boolean;
+    };
+    accessToken: string;
+    accessTokenExpiresAt: string;
+    refreshToken: string;
+    refreshTokenExpiresAt: string;
+    mfaRequired?: false | undefined;
+    mfaEnrollmentRequired?: boolean | undefined;
+}>;
+export type AuthResultDto = z.infer<typeof AuthResultDtoSchema>;
+/**
+ * The user passed the primary factor (password / OAuth) but has MFA
+ * enrolled. The customer's server must prompt the user for their TOTP /
+ * backup code and POST it to /auth/mfa-verify along with
+ * `mfaChallengeToken` to receive a real session.
+ *
+ * The challenge token is short-lived (5 min) and bound to (endUser,
+ * application). It is **not** a session token — it cannot be used at any
+ * other endpoint.
+ */
+export declare const MfaChallengeResultDtoSchema: z.ZodObject<{
+    mfaRequired: z.ZodLiteral<true>;
+    endUser: z.ZodObject<{
+        id: z.ZodString;
+        applicationId: z.ZodString;
+        email: z.ZodString;
+        emailVerified: z.ZodBoolean;
+        metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        createdAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        email: string;
+        emailVerified: boolean;
+    }, {
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        email: string;
+        emailVerified: boolean;
+    }>;
+    mfaChallengeToken: z.ZodString;
+    mfaChallengeExpiresAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    mfaRequired: true;
+    endUser: {
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        email: string;
+        emailVerified: boolean;
+    };
+    mfaChallengeToken: string;
+    mfaChallengeExpiresAt: string;
+}, {
+    mfaRequired: true;
+    endUser: {
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        email: string;
+        emailVerified: boolean;
+    };
+    mfaChallengeToken: string;
+    mfaChallengeExpiresAt: string;
+}>;
+export type MfaChallengeResultDto = z.infer<typeof MfaChallengeResultDtoSchema>;
+/**
+ * Discriminated union over `mfaRequired`. Returned by `signIn`, OAuth
+ * `callback`, and any future flow that accepts a primary factor — the
+ * client always branches on `mfaRequired` to decide whether to render the
+ * second-factor prompt or store the session tokens.
+ */
+export declare const SignInOutcomeDtoSchema: z.ZodDiscriminatedUnion<"mfaRequired", [z.ZodObject<{
+    mfaRequired: z.ZodDefault<z.ZodLiteral<false>>;
+    /**
+     * True when the Application's MFA policy is `required` but this user has not
+     * enrolled yet. The session is still issued; the app should route the user
+     * to MFA setup before granting sensitive access.
+     */
+    mfaEnrollmentRequired: z.ZodOptional<z.ZodBoolean>;
+    endUser: z.ZodObject<{
+        id: z.ZodString;
+        applicationId: z.ZodString;
+        email: z.ZodString;
+        emailVerified: z.ZodBoolean;
+        metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        createdAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        email: string;
+        emailVerified: boolean;
+    }, {
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        email: string;
+        emailVerified: boolean;
+    }>;
+    /** Short-lived access JWT. Pass via X-Relipay-User-Token. */
+    accessToken: z.ZodString;
+    accessTokenExpiresAt: z.ZodString;
+    /** Long-lived refresh token. Use to mint new access tokens via auth.refresh(). */
+    refreshToken: z.ZodString;
+    refreshTokenExpiresAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    mfaRequired: false;
+    endUser: {
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        email: string;
+        emailVerified: boolean;
+    };
+    accessToken: string;
+    accessTokenExpiresAt: string;
+    refreshToken: string;
+    refreshTokenExpiresAt: string;
+    mfaEnrollmentRequired?: boolean | undefined;
+}, {
+    endUser: {
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        email: string;
+        emailVerified: boolean;
+    };
+    accessToken: string;
+    accessTokenExpiresAt: string;
+    refreshToken: string;
+    refreshTokenExpiresAt: string;
+    mfaRequired?: false | undefined;
+    mfaEnrollmentRequired?: boolean | undefined;
+}>, z.ZodObject<{
+    mfaRequired: z.ZodLiteral<true>;
+    endUser: z.ZodObject<{
+        id: z.ZodString;
+        applicationId: z.ZodString;
+        email: z.ZodString;
+        emailVerified: z.ZodBoolean;
+        metadata: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        createdAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        email: string;
+        emailVerified: boolean;
+    }, {
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        email: string;
+        emailVerified: boolean;
+    }>;
+    mfaChallengeToken: z.ZodString;
+    mfaChallengeExpiresAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    mfaRequired: true;
+    endUser: {
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        email: string;
+        emailVerified: boolean;
+    };
+    mfaChallengeToken: string;
+    mfaChallengeExpiresAt: string;
+}, {
+    mfaRequired: true;
+    endUser: {
+        metadata: Record<string, unknown> | null;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        email: string;
+        emailVerified: boolean;
+    };
+    mfaChallengeToken: string;
+    mfaChallengeExpiresAt: string;
+}>]>;
+export type SignInOutcomeDto = z.infer<typeof SignInOutcomeDtoSchema>;
+export declare const MfaVerifyRequestSchema: z.ZodObject<{
+    mfaChallengeToken: z.ZodString;
+    code: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    mfaChallengeToken: string;
+}, {
+    code: string;
+    mfaChallengeToken: string;
+}>;
+export type MfaVerifyRequest = z.infer<typeof MfaVerifyRequestSchema>;
+export declare const RefreshRequestSchema: z.ZodObject<{
+    refreshToken: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    refreshToken: string;
+}, {
+    refreshToken: string;
+}>;
+export type RefreshRequest = z.infer<typeof RefreshRequestSchema>;
+export declare const ForgotPasswordRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+    /**
+     * Optional URL for the reset link in the email. `{token}` will be
+     * URL-encoded and substituted by the server. Required only if you've
+     * configured email transport — otherwise the server returns the raw
+     * token in the response for you to forward.
+     */
+    resetUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    resetUrl?: string | undefined;
+}, {
+    email: string;
+    resetUrl?: string | undefined;
+}>;
+export type ForgotPasswordRequest = z.infer<typeof ForgotPasswordRequestSchema>;
+export declare const ForgotPasswordResultDtoSchema: z.ZodObject<{
+    /** True iff a real user existed and a token was minted. False is also returned when the email is unknown — never enumerate. */
+    delivered: z.ZodBoolean;
+    /**
+     * True iff ReliPay sent the email itself (BYO Resend creds or
+     * RESEND_DEFAULT_* env configured). When true, `resetToken` is null and
+     * no further action is needed from the caller.
+     */
+    emailSent: z.ZodBoolean;
+    /**
+     * Raw reset token. Null when `delivered` is false (unknown email) OR
+     * when `emailSent` is true (we delivered it). Present when the customer's
+     * server is expected to forward it via its own provider.
+     */
+    resetToken: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    delivered: boolean;
+    emailSent: boolean;
+    resetToken: string | null;
+}, {
+    delivered: boolean;
+    emailSent: boolean;
+    resetToken: string | null;
+}>;
+export type ForgotPasswordResultDto = z.infer<typeof ForgotPasswordResultDtoSchema>;
+export declare const SendVerificationRequestSchema: z.ZodObject<{
+    /** Optional URL for the verify link. `{token}` is URL-encoded + substituted. */
+    verifyUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    verifyUrl?: string | undefined;
+}, {
+    verifyUrl?: string | undefined;
+}>;
+export type SendVerificationRequest = z.infer<typeof SendVerificationRequestSchema>;
+export declare const SendVerificationResultDtoSchema: z.ZodObject<{
+    /** True iff ReliPay sent the email via its transport. */
+    emailSent: z.ZodBoolean;
+    /** Raw verification token; null when emailSent is true. */
+    verificationToken: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    emailSent: boolean;
+    verificationToken: string | null;
+}, {
+    emailSent: boolean;
+    verificationToken: string | null;
+}>;
+export type SendVerificationResultDto = z.infer<typeof SendVerificationResultDtoSchema>;
+export declare const VerifyEmailRequestSchema: z.ZodObject<{
+    token: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    token: string;
+}, {
+    token: string;
+}>;
+export type VerifyEmailRequest = z.infer<typeof VerifyEmailRequestSchema>;
+/**
+ * Known transactional email events. Templates can be customised per
+ * Application in the panel. New events are added as part of a release;
+ * older SDK versions will see unknown keys as plain strings.
+ */
+export declare const EmailEventKeySchema: z.ZodEnum<["password_reset", "email_verification", "workspace_invitation", "welcome", "mfa_enabled", "password_changed"]>;
+export type EmailEventKey = z.infer<typeof EmailEventKeySchema>;
+export declare const ResetPasswordRequestSchema: z.ZodObject<{
+    token: z.ZodString;
+    newPassword: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    token: string;
+    newPassword: string;
+}, {
+    token: string;
+    newPassword: string;
+}>;
+export type ResetPasswordRequest = z.infer<typeof ResetPasswordRequestSchema>;
+export declare const ChangePasswordRequestSchema: z.ZodObject<{
+    currentPassword: z.ZodString;
+    newPassword: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    newPassword: string;
+    currentPassword: string;
+}, {
+    newPassword: string;
+    currentPassword: string;
+}>;
+export type ChangePasswordRequest = z.infer<typeof ChangePasswordRequestSchema>;
+export declare const PlanIntervalSchema: z.ZodEnum<["MONTH", "YEAR"]>;
+export type PlanIntervalType = z.infer<typeof PlanIntervalSchema>;
+/** What a plan sells. SUBSCRIPTION = recurring; LICENSE = key issued on purchase; USAGE = metered; CREDIT = prepaid balance / lead pack. */
+export declare const PlanKindSchema: z.ZodEnum<["SUBSCRIPTION", "LICENSE", "USAGE", "CREDIT"]>;
+export type PlanKindType = z.infer<typeof PlanKindSchema>;
+/** Shape of a LICENSE-kind plan's key. PERPETUAL = never expires; TIMED = N-day; SEATS = capped activations. */
+export declare const LicenseKindSchema: z.ZodEnum<["PERPETUAL", "TIMED", "SEATS"]>;
+export type LicenseKindType = z.infer<typeof LicenseKindSchema>;
+export declare const SubscriptionStatusSchema: z.ZodEnum<["PENDING", "ACTIVE", "PAST_DUE", "CANCELED", "EXPIRED"]>;
+export type SubscriptionStatusType = z.infer<typeof SubscriptionStatusSchema>;
+export declare const PlanDtoSchema: z.ZodObject<{
+    id: z.ZodString;
+    applicationId: z.ZodString;
+    slug: z.ZodString;
+    name: z.ZodString;
+    /** Amount in the smallest currency unit (cents/paise/sen). Always integer. */
+    amount: z.ZodNumber;
+    currency: z.ZodString;
+    interval: z.ZodEnum<["MONTH", "YEAR"]>;
+    /** What this plan sells. Defaults to SUBSCRIPTION for plans created before kinds existed. */
+    kind: z.ZodEnum<["SUBSCRIPTION", "LICENSE", "USAGE", "CREDIT"]>;
+    licenseKind: z.ZodNullable<z.ZodEnum<["PERPETUAL", "TIMED", "SEATS"]>>;
+    licenseSeatsAllowed: z.ZodNullable<z.ZodNumber>;
+    /** For TIMED licenses: key lifetime in days from purchase. */
+    licenseDurationDays: z.ZodNullable<z.ZodNumber>;
+    /** Slug of the usage meter this plan bills against. */
+    meterSlug: z.ZodNullable<z.ZodString>;
+    /** Per-unit price in the smallest currency unit. `amount` is the base/recurring fee. */
+    pricePerUnitCents: z.ZodNullable<z.ZodNumber>;
+    /** Credits granted to the buyer on successful payment of a CREDIT-kind plan. */
+    creditsAmount: z.ZodNullable<z.ZodNumber>;
+    active: z.ZodBoolean;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    currency: string;
+    metadata: Record<string, unknown>;
+    id: string;
+    name: string;
+    slug: string;
+    createdAt: string;
+    applicationId: string;
+    amount: number;
+    interval: "MONTH" | "YEAR";
+    kind: "SUBSCRIPTION" | "LICENSE" | "USAGE" | "CREDIT";
+    licenseKind: "PERPETUAL" | "TIMED" | "SEATS" | null;
+    licenseSeatsAllowed: number | null;
+    licenseDurationDays: number | null;
+    meterSlug: string | null;
+    pricePerUnitCents: number | null;
+    creditsAmount: number | null;
+    active: boolean;
+    updatedAt: string;
+}, {
+    currency: string;
+    metadata: Record<string, unknown>;
+    id: string;
+    name: string;
+    slug: string;
+    createdAt: string;
+    applicationId: string;
+    amount: number;
+    interval: "MONTH" | "YEAR";
+    kind: "SUBSCRIPTION" | "LICENSE" | "USAGE" | "CREDIT";
+    licenseKind: "PERPETUAL" | "TIMED" | "SEATS" | null;
+    licenseSeatsAllowed: number | null;
+    licenseDurationDays: number | null;
+    meterSlug: string | null;
+    pricePerUnitCents: number | null;
+    creditsAmount: number | null;
+    active: boolean;
+    updatedAt: string;
+}>;
+export type PlanDto = z.infer<typeof PlanDtoSchema>;
+export declare const CreditReasonSchema: z.ZodEnum<["PURCHASE", "GRANT", "CONSUME", "REFUND", "ADJUST"]>;
+export type CreditReasonType = z.infer<typeof CreditReasonSchema>;
+export declare const CreditBalanceDtoSchema: z.ZodObject<{
+    applicationId: z.ZodString;
+    endUserId: z.ZodString;
+    /** Current spendable balance (whole credits, never negative). */
+    balance: z.ZodNumber;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    applicationId: string;
+    updatedAt: string;
+    endUserId: string;
+    balance: number;
+}, {
+    applicationId: string;
+    updatedAt: string;
+    endUserId: string;
+    balance: number;
+}>;
+export type CreditBalanceDto = z.infer<typeof CreditBalanceDtoSchema>;
+export declare const CreditLedgerEntryDtoSchema: z.ZodObject<{
+    id: z.ZodString;
+    /** Signed change: + added (purchase/grant/refund), − consumed. */
+    delta: z.ZodNumber;
+    reason: z.ZodEnum<["PURCHASE", "GRANT", "CONSUME", "REFUND", "ADJUST"]>;
+    /** Balance immediately after this entry. */
+    balanceAfter: z.ZodNumber;
+    description: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    metadata: Record<string, unknown>;
+    id: string;
+    createdAt: string;
+    delta: number;
+    reason: "PURCHASE" | "GRANT" | "CONSUME" | "REFUND" | "ADJUST";
+    balanceAfter: number;
+    description: string | null;
+}, {
+    metadata: Record<string, unknown>;
+    id: string;
+    createdAt: string;
+    delta: number;
+    reason: "PURCHASE" | "GRANT" | "CONSUME" | "REFUND" | "ADJUST";
+    balanceAfter: number;
+    description: string | null;
+}>;
+export type CreditLedgerEntryDto = z.infer<typeof CreditLedgerEntryDtoSchema>;
+/** Body for POST /api/v1/credits/consume (end-user drawdown). */
+export declare const ConsumeCreditsRequestSchema: z.ZodObject<{
+    /** How many credits to deduct. Must be a positive integer. */
+    amount: z.ZodNumber;
+    /**
+     * Optional idempotency key (e.g. the lead id). A repeated consume with the
+     * same key is a no-op that returns the original result — safe to retry.
+     */
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    amount: number;
+    metadata?: Record<string, unknown> | undefined;
+    description?: string | undefined;
+    idempotencyKey?: string | undefined;
+}, {
+    amount: number;
+    metadata?: Record<string, unknown> | undefined;
+    description?: string | undefined;
+    idempotencyKey?: string | undefined;
+}>;
+export type ConsumeCreditsRequest = z.infer<typeof ConsumeCreditsRequestSchema>;
+/** Body for the operator grant endpoint (manual top-up / adjustment). */
+export declare const GrantCreditsRequestSchema: z.ZodObject<{
+    /** Credits to add (positive) or remove (negative, for ADJUST). */
+    amount: z.ZodNumber;
+    reason: z.ZodDefault<z.ZodEnum<["GRANT", "REFUND", "ADJUST"]>>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    amount: number;
+    reason: "GRANT" | "REFUND" | "ADJUST";
+    metadata?: Record<string, unknown> | undefined;
+    description?: string | undefined;
+    idempotencyKey?: string | undefined;
+}, {
+    amount: number;
+    metadata?: Record<string, unknown> | undefined;
+    reason?: "GRANT" | "REFUND" | "ADJUST" | undefined;
+    description?: string | undefined;
+    idempotencyKey?: string | undefined;
+}>;
+export type GrantCreditsRequest = z.infer<typeof GrantCreditsRequestSchema>;
+export declare const SubscriptionDtoSchema: z.ZodObject<{
+    id: z.ZodString;
+    applicationId: z.ZodString;
+    endUserId: z.ZodString;
+    planId: z.ZodString;
+    status: z.ZodEnum<["PENDING", "ACTIVE", "PAST_DUE", "CANCELED", "EXPIRED"]>;
+    currentPeriodEnd: z.ZodNullable<z.ZodString>;
+    cancelAt: z.ZodNullable<z.ZodString>;
+    canceledAt: z.ZodNullable<z.ZodString>;
+    providerSubId: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "PENDING" | "ACTIVE" | "PAST_DUE" | "CANCELED" | "EXPIRED";
+    metadata: Record<string, unknown>;
+    id: string;
+    createdAt: string;
+    applicationId: string;
+    updatedAt: string;
+    endUserId: string;
+    planId: string;
+    currentPeriodEnd: string | null;
+    cancelAt: string | null;
+    canceledAt: string | null;
+    providerSubId: string | null;
+}, {
+    status: "PENDING" | "ACTIVE" | "PAST_DUE" | "CANCELED" | "EXPIRED";
+    metadata: Record<string, unknown>;
+    id: string;
+    createdAt: string;
+    applicationId: string;
+    updatedAt: string;
+    endUserId: string;
+    planId: string;
+    currentPeriodEnd: string | null;
+    cancelAt: string | null;
+    canceledAt: string | null;
+    providerSubId: string | null;
+}>;
+export type SubscriptionDto = z.infer<typeof SubscriptionDtoSchema>;
+export declare const CreateCheckoutRequestSchema: z.ZodObject<{
+    planSlug: z.ZodString;
+    successUrl: z.ZodString;
+    cancelUrl: z.ZodString;
+    /**
+     * Optional billing provider override. When omitted, the geo router picks
+     * one from the Application's enabled providers using `country` and the
+     * per-provider routing rules.
+     */
+    provider: z.ZodOptional<z.ZodEnum<["stripe", "paypal", "razorpay"]>>;
+    /** ISO 3166-1 alpha-2. Used by the geo router when `provider` is absent. */
+    country: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    planSlug: string;
+    successUrl: string;
+    cancelUrl: string;
+    provider?: "stripe" | "paypal" | "razorpay" | undefined;
+    country?: string | undefined;
+}, {
+    planSlug: string;
+    successUrl: string;
+    cancelUrl: string;
+    provider?: "stripe" | "paypal" | "razorpay" | undefined;
+    country?: string | undefined;
+}>;
+export type CreateCheckoutRequest = z.infer<typeof CreateCheckoutRequestSchema>;
+export declare const CreateCheckoutRequestWithCouponSchema: z.ZodObject<{
+    planSlug: z.ZodString;
+    successUrl: z.ZodString;
+    cancelUrl: z.ZodString;
+    /**
+     * Optional billing provider override. When omitted, the geo router picks
+     * one from the Application's enabled providers using `country` and the
+     * per-provider routing rules.
+     */
+    provider: z.ZodOptional<z.ZodEnum<["stripe", "paypal", "razorpay"]>>;
+    /** ISO 3166-1 alpha-2. Used by the geo router when `provider` is absent. */
+    country: z.ZodOptional<z.ZodString>;
+} & {
+    couponCode: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    planSlug: string;
+    successUrl: string;
+    cancelUrl: string;
+    provider?: "stripe" | "paypal" | "razorpay" | undefined;
+    country?: string | undefined;
+    couponCode?: string | undefined;
+}, {
+    planSlug: string;
+    successUrl: string;
+    cancelUrl: string;
+    provider?: "stripe" | "paypal" | "razorpay" | undefined;
+    country?: string | undefined;
+    couponCode?: string | undefined;
+}>;
+export declare const CheckoutResultDtoSchema: z.ZodObject<{
+    url: z.ZodString;
+    subscription: z.ZodObject<{
+        id: z.ZodString;
+        applicationId: z.ZodString;
+        endUserId: z.ZodString;
+        planId: z.ZodString;
+        status: z.ZodEnum<["PENDING", "ACTIVE", "PAST_DUE", "CANCELED", "EXPIRED"]>;
+        currentPeriodEnd: z.ZodNullable<z.ZodString>;
+        cancelAt: z.ZodNullable<z.ZodString>;
+        canceledAt: z.ZodNullable<z.ZodString>;
+        providerSubId: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        status: "PENDING" | "ACTIVE" | "PAST_DUE" | "CANCELED" | "EXPIRED";
+        metadata: Record<string, unknown>;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        updatedAt: string;
+        endUserId: string;
+        planId: string;
+        currentPeriodEnd: string | null;
+        cancelAt: string | null;
+        canceledAt: string | null;
+        providerSubId: string | null;
+    }, {
+        status: "PENDING" | "ACTIVE" | "PAST_DUE" | "CANCELED" | "EXPIRED";
+        metadata: Record<string, unknown>;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        updatedAt: string;
+        endUserId: string;
+        planId: string;
+        currentPeriodEnd: string | null;
+        cancelAt: string | null;
+        canceledAt: string | null;
+        providerSubId: string | null;
+    }>;
+    /** Discount applied (smallest currency unit). 0 if no coupon. */
+    discountAmount: z.ZodNumber;
+    /** Which provider issued this checkout. Stamped on Subscription.provider. */
+    provider: z.ZodEnum<["stripe", "paypal", "razorpay"]>;
+}, "strip", z.ZodTypeAny, {
+    provider: "stripe" | "paypal" | "razorpay";
+    url: string;
+    subscription: {
+        status: "PENDING" | "ACTIVE" | "PAST_DUE" | "CANCELED" | "EXPIRED";
+        metadata: Record<string, unknown>;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        updatedAt: string;
+        endUserId: string;
+        planId: string;
+        currentPeriodEnd: string | null;
+        cancelAt: string | null;
+        canceledAt: string | null;
+        providerSubId: string | null;
+    };
+    discountAmount: number;
+}, {
+    provider: "stripe" | "paypal" | "razorpay";
+    url: string;
+    subscription: {
+        status: "PENDING" | "ACTIVE" | "PAST_DUE" | "CANCELED" | "EXPIRED";
+        metadata: Record<string, unknown>;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        updatedAt: string;
+        endUserId: string;
+        planId: string;
+        currentPeriodEnd: string | null;
+        cancelAt: string | null;
+        canceledAt: string | null;
+        providerSubId: string | null;
+    };
+    discountAmount: number;
+}>;
+export type CheckoutResultDto = z.infer<typeof CheckoutResultDtoSchema>;
+export declare const BillingProviderInfoDtoSchema: z.ZodObject<{
+    provider: z.ZodEnum<["stripe", "paypal", "razorpay"]>;
+    priority: z.ZodNumber;
+    countries: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    provider: "stripe" | "paypal" | "razorpay";
+    priority: number;
+    countries: string[];
+}, {
+    provider: "stripe" | "paypal" | "razorpay";
+    priority: number;
+    countries: string[];
+}>;
+export type BillingProviderInfoDto = z.infer<typeof BillingProviderInfoDtoSchema>;
+export declare const ProvidersListDtoSchema: z.ZodObject<{
+    country: z.ZodNullable<z.ZodString>;
+    providers: z.ZodArray<z.ZodObject<{
+        provider: z.ZodEnum<["stripe", "paypal", "razorpay"]>;
+        priority: z.ZodNumber;
+        countries: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        provider: "stripe" | "paypal" | "razorpay";
+        priority: number;
+        countries: string[];
+    }, {
+        provider: "stripe" | "paypal" | "razorpay";
+        priority: number;
+        countries: string[];
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    country: string | null;
+    providers: {
+        provider: "stripe" | "paypal" | "razorpay";
+        priority: number;
+        countries: string[];
+    }[];
+}, {
+    country: string | null;
+    providers: {
+        provider: "stripe" | "paypal" | "razorpay";
+        priority: number;
+        countries: string[];
+    }[];
+}>;
+export type ProvidersListDto = z.infer<typeof ProvidersListDtoSchema>;
+export declare const CouponDiscountTypeSchema: z.ZodEnum<["PERCENT", "AMOUNT"]>;
+export type CouponDiscountTypeValue = z.infer<typeof CouponDiscountTypeSchema>;
+export declare const CouponDtoSchema: z.ZodObject<{
+    id: z.ZodString;
+    applicationId: z.ZodString;
+    code: z.ZodString;
+    discountType: z.ZodEnum<["PERCENT", "AMOUNT"]>;
+    /** PERCENT: basis-points × 10 (1500 = 15.00%). AMOUNT: smallest currency unit. */
+    amountOff: z.ZodNumber;
+    currency: z.ZodNullable<z.ZodString>;
+    planSlugs: z.ZodArray<z.ZodString, "many">;
+    active: z.ZodBoolean;
+    startsAt: z.ZodNullable<z.ZodString>;
+    endsAt: z.ZodNullable<z.ZodString>;
+    maxRedemptions: z.ZodNullable<z.ZodNumber>;
+    maxRedemptionsPerUser: z.ZodNullable<z.ZodNumber>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    currency: string | null;
+    metadata: Record<string, unknown>;
+    id: string;
+    createdAt: string;
+    applicationId: string;
+    active: boolean;
+    updatedAt: string;
+    discountType: "PERCENT" | "AMOUNT";
+    amountOff: number;
+    planSlugs: string[];
+    startsAt: string | null;
+    endsAt: string | null;
+    maxRedemptions: number | null;
+    maxRedemptionsPerUser: number | null;
+}, {
+    code: string;
+    currency: string | null;
+    metadata: Record<string, unknown>;
+    id: string;
+    createdAt: string;
+    applicationId: string;
+    active: boolean;
+    updatedAt: string;
+    discountType: "PERCENT" | "AMOUNT";
+    amountOff: number;
+    planSlugs: string[];
+    startsAt: string | null;
+    endsAt: string | null;
+    maxRedemptions: number | null;
+    maxRedemptionsPerUser: number | null;
+}>;
+export type CouponDto = z.infer<typeof CouponDtoSchema>;
+export declare const ValidateCouponRequestSchema: z.ZodObject<{
+    code: z.ZodString;
+    planSlug: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    planSlug: string;
+}, {
+    code: string;
+    planSlug: string;
+}>;
+export type ValidateCouponRequest = z.infer<typeof ValidateCouponRequestSchema>;
+export declare const ValidateCouponResultDtoSchema: z.ZodObject<{
+    coupon: z.ZodObject<{
+        id: z.ZodString;
+        applicationId: z.ZodString;
+        code: z.ZodString;
+        discountType: z.ZodEnum<["PERCENT", "AMOUNT"]>;
+        /** PERCENT: basis-points × 10 (1500 = 15.00%). AMOUNT: smallest currency unit. */
+        amountOff: z.ZodNumber;
+        currency: z.ZodNullable<z.ZodString>;
+        planSlugs: z.ZodArray<z.ZodString, "many">;
+        active: z.ZodBoolean;
+        startsAt: z.ZodNullable<z.ZodString>;
+        endsAt: z.ZodNullable<z.ZodString>;
+        maxRedemptions: z.ZodNullable<z.ZodNumber>;
+        maxRedemptionsPerUser: z.ZodNullable<z.ZodNumber>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        currency: string | null;
+        metadata: Record<string, unknown>;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        active: boolean;
+        updatedAt: string;
+        discountType: "PERCENT" | "AMOUNT";
+        amountOff: number;
+        planSlugs: string[];
+        startsAt: string | null;
+        endsAt: string | null;
+        maxRedemptions: number | null;
+        maxRedemptionsPerUser: number | null;
+    }, {
+        code: string;
+        currency: string | null;
+        metadata: Record<string, unknown>;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        active: boolean;
+        updatedAt: string;
+        discountType: "PERCENT" | "AMOUNT";
+        amountOff: number;
+        planSlugs: string[];
+        startsAt: string | null;
+        endsAt: string | null;
+        maxRedemptions: number | null;
+        maxRedemptionsPerUser: number | null;
+    }>;
+    plan: z.ZodObject<{
+        slug: z.ZodString;
+        name: z.ZodString;
+        amount: z.ZodNumber;
+        currency: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        currency: string;
+        name: string;
+        slug: string;
+        amount: number;
+    }, {
+        currency: string;
+        name: string;
+        slug: string;
+        amount: number;
+    }>;
+    discountAmount: z.ZodNumber;
+    amountAfterDiscount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    discountAmount: number;
+    coupon: {
+        code: string;
+        currency: string | null;
+        metadata: Record<string, unknown>;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        active: boolean;
+        updatedAt: string;
+        discountType: "PERCENT" | "AMOUNT";
+        amountOff: number;
+        planSlugs: string[];
+        startsAt: string | null;
+        endsAt: string | null;
+        maxRedemptions: number | null;
+        maxRedemptionsPerUser: number | null;
+    };
+    plan: {
+        currency: string;
+        name: string;
+        slug: string;
+        amount: number;
+    };
+    amountAfterDiscount: number;
+}, {
+    discountAmount: number;
+    coupon: {
+        code: string;
+        currency: string | null;
+        metadata: Record<string, unknown>;
+        id: string;
+        createdAt: string;
+        applicationId: string;
+        active: boolean;
+        updatedAt: string;
+        discountType: "PERCENT" | "AMOUNT";
+        amountOff: number;
+        planSlugs: string[];
+        startsAt: string | null;
+        endsAt: string | null;
+        maxRedemptions: number | null;
+        maxRedemptionsPerUser: number | null;
+    };
+    plan: {
+        currency: string;
+        name: string;
+        slug: string;
+        amount: number;
+    };
+    amountAfterDiscount: number;
+}>;
+export type ValidateCouponResultDto = z.infer<typeof ValidateCouponResultDtoSchema>;
+//# sourceMappingURL=index.d.ts.map