import { M as Member, a as Plan, c as PlanConnection, g as MemberCard, b as Price, A as App, C as ContentGroup } from '../models-CXju0WFP.js';

/**
 * @fileoverview Test utilities for Memberstack SDK.
 * Provides mock factories and helpers for testing applications that use Memberstack.
 *
 * @example
 * ```typescript
 * import { createMockMemberstack, mockMember, mockPlan } from '@memberstack/dom/testing';
 *
 * // Create a mock SDK instance
 * const mockMs = createMockMemberstack({
 *   member: mockMember({ email: 'test@example.com' }),
 *   plans: [mockPlan({ name: 'Pro' })]
 * });
 *
 * // Use in tests
 * const { data: member } = await mockMs.getCurrentMember();
 * expect(member?.auth.email).toBe('test@example.com');
 * ```
 *
 * @packageDocumentation
 */

/**
 * Creates a mock member object with sensible defaults.
 * Override any property by passing it in the options.
 *
 * @param overrides - Partial member data to override defaults
 * @returns A complete mock Member object
 *
 * @example
 * ```typescript
 * // Basic usage
 * const member = mockMember();
 *
 * // With custom email
 * const member = mockMember({ auth: { email: 'custom@test.com' } });
 *
 * // With plans
 * const member = mockMember({
 *   planConnections: [mockPlanConnection({ planId: 'pln_abc123' })]
 * });
 * ```
 */
declare function mockMember(overrides?: DeepPartial<Member>): Member;
/**
 * Creates a mock plan object.
 *
 * @param overrides - Partial plan data to override defaults
 * @returns A complete mock Plan object
 *
 * @example
 * ```typescript
 * const freePlan = mockPlan({ name: 'Free', prices: [] });
 * const proPlan = mockPlan({
 *   name: 'Pro',
 *   prices: [mockPrice({ amount: '9.99' })]
 * });
 * ```
 */
declare function mockPlan(overrides?: DeepPartial<Plan>): Plan;
/**
 * Creates a mock plan connection (member's subscription to a plan).
 *
 * @param overrides - Partial connection data to override defaults
 * @returns A complete mock PlanConnection object
 *
 * @example
 * ```typescript
 * // Active subscription
 * const conn = mockPlanConnection({ active: true, status: 'ACTIVE' });
 *
 * // Canceled subscription
 * const conn = mockPlanConnection({
 *   active: false,
 *   status: 'CANCELED',
 *   payment: { cancelAtDate: Date.now() + 86400000 }
 * });
 * ```
 */
declare function mockPlanConnection(overrides?: DeepPartial<PlanConnection>): PlanConnection;
/**
 * Creates a mock payment card.
 *
 * @param overrides - Partial card data to override defaults
 * @returns A complete mock MemberCard object
 */
declare function mockCard(overrides?: DeepPartial<MemberCard>): MemberCard;
/**
 * Creates a mock price object for a plan.
 *
 * @param overrides - Partial price data to override defaults
 * @returns A complete mock Price object
 *
 * @example
 * ```typescript
 * const monthlyPrice = mockPrice({ amount: '9.99', name: 'Monthly' });
 * const yearlyPrice = mockPrice({
 *   amount: '99.99',
 *   name: 'Yearly',
 *   interval: { type: 'year', count: 1 }
 * });
 * ```
 */
declare function mockPrice(overrides?: DeepPartial<Price>): Price;
/**
 * Creates a mock app configuration.
 *
 * @param overrides - Partial app data to override defaults
 * @returns A complete mock App object
 */
declare function mockApp(overrides?: DeepPartial<App>): App;
/**
 * Creates a mock content group (restricted URL group).
 *
 * @param overrides - Partial group data to override defaults
 * @returns A complete mock ContentGroup object
 */
declare function mockContentGroup(overrides?: DeepPartial<ContentGroup>): ContentGroup;
/**
 * Options for creating a mock Memberstack instance.
 */
interface MockMemberstackOptions {
    /** The currently logged-in member, or null if logged out */
    member?: Member | null;
    /** Available plans in the app */
    plans?: Plan[];
    /** App configuration */
    app?: App;
    /** Content groups */
    contentGroups?: ContentGroup[];
    /** Member's saved cards */
    cards?: MemberCard[];
    /** Custom method overrides */
    overrides?: Partial<MockMemberstackInstance>;
}
/**
 * Mock implementation of the Memberstack SDK.
 * Implements the most commonly used methods for testing.
 */
interface MockMemberstackInstance {
    getCurrentMember: () => Promise<{
        data: Member | null;
    }>;
    getPlans: () => Promise<{
        data: Plan[];
    }>;
    getPlan: (params: {
        planId: string;
    }) => Promise<{
        data: Plan | null;
    }>;
    getApp: () => Promise<{
        data: App;
    }>;
    getRestrictedUrlGroups: () => Promise<{
        data: ContentGroup[];
    }>;
    getMemberCards: () => Promise<{
        data: MemberCard[];
    }>;
    loginMemberEmailPassword: (params: {
        email: string;
        password: string;
    }) => Promise<{
        data: {
            member: Member;
            tokens: {
                accessToken: string;
                expires: number;
                type: string;
            };
            redirect: string;
        };
    }>;
    signupMemberEmailPassword: (params: {
        email: string;
        password: string;
    }) => Promise<{
        data: {
            member: Member;
            tokens: {
                accessToken: string;
                expires: number;
                type: string;
            };
            redirect: string;
        };
    }>;
    logout: () => Promise<{
        data: {
            redirect?: string;
        };
    }>;
    updateMember: (params: {
        customFields?: object;
    }) => Promise<{
        data: Member;
    }>;
    onAuthChange: (callback: (payload: {
        member: Member | null;
    }) => void) => () => void;
    _setMember: (member: Member | null) => void;
    _getMockState: () => {
        member: Member | null;
        plans: Plan[];
        app: App;
    };
}
/**
 * Creates a mock Memberstack SDK instance for testing.
 * All methods return promises with mock data based on the provided options.
 *
 * @param options - Configuration for the mock instance
 * @returns A mock Memberstack instance with common methods
 *
 * @example
 * ```typescript
 * // Basic setup
 * const mockMs = createMockMemberstack({
 *   member: mockMember({ auth: { email: 'test@test.com' } }),
 *   plans: [mockPlan({ name: 'Free' }), mockPlan({ name: 'Pro' })]
 * });
 *
 * // Use in component tests
 * const { data: member } = await mockMs.getCurrentMember();
 * expect(member).not.toBeNull();
 *
 * // Test logout flow
 * await mockMs.logout();
 * const { data: afterLogout } = await mockMs.getCurrentMember();
 * expect(afterLogout).toBeNull();
 *
 * // Subscribe to auth changes
 * const authCallback = jest.fn();
 * mockMs.onAuthChange(authCallback);
 * mockMs._setMember(null); // Simulate logout
 * expect(authCallback).toHaveBeenCalledWith({ member: null });
 * ```
 */
declare function createMockMemberstack(options?: MockMemberstackOptions): MockMemberstackInstance;
/** Deep partial type for nested object overrides */
type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};
/**
 * Custom matchers for testing Memberstack data.
 * These can be extended with Jest's expect.extend() or Vitest's expect.extend().
 *
 * @example
 * ```typescript
 * // In your test setup file:
 * import { memberstackMatchers } from '@memberstack/dom/testing';
 * expect.extend(memberstackMatchers);
 *
 * // In tests:
 * expect(member).toBeLoggedIn();
 * expect(member).toHavePlan('pln_abc123');
 * ```
 */
declare const memberstackMatchers: {
    /**
     * Assert that a member is logged in (not null and has an email).
     */
    toBeLoggedIn(received: Member | null): {
        pass: boolean;
        message: () => string;
    };
    /**
     * Assert that a member has a specific plan.
     */
    toHavePlan(received: Member | null, planId: string): {
        pass: boolean;
        message: () => string;
    };
    /**
     * Assert that a member's email is verified.
     */
    toBeVerified(received: Member | null): {
        pass: boolean;
        message: () => "Expected member not to be verified" | "Expected member to be verified";
    };
};
declare global {
    namespace jest {
        interface Matchers<R> {
            toBeLoggedIn(): R;
            toHavePlan(planId: string): R;
            toBeVerified(): R;
        }
    }
}

export { type MockMemberstackInstance, type MockMemberstackOptions, createMockMemberstack, memberstackMatchers, mockApp, mockCard, mockContentGroup, mockMember, mockPlan, mockPlanConnection, mockPrice };