import * as Apollo from '@apollo/client';
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Exact<T extends {
    [key: string]: unknown;
}> = {
    [K in keyof T]: T[K];
};
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]?: Maybe<T[SubKey]>;
};
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
    [SubKey in K]: Maybe<T[SubKey]>;
};
export type MakeEmpty<T extends {
    [key: string]: unknown;
}, K extends keyof T> = {
    [_ in K]?: never;
};
export type Incremental<T> = T | {
    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
};
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
    ID: {
        input: string;
        output: string;
    };
    String: {
        input: string;
        output: string;
    };
    Boolean: {
        input: boolean;
        output: boolean;
    };
    Int: {
        input: number;
        output: number;
    };
    Float: {
        input: number;
        output: number;
    };
    BigInt: {
        input: any;
        output: any;
    };
    CountryCode: {
        input: any;
        output: any;
    };
    Date: {
        input: any;
        output: any;
    };
    DateTime: {
        input: any;
        output: any;
    };
    EmailAddress: {
        input: any;
        output: any;
    };
    JSON: {
        input: any;
        output: any;
    };
    PhoneNumber: {
        input: any;
        output: any;
    };
    Timestamp: {
        input: any;
        output: any;
    };
    URL: {
        input: any;
        output: any;
    };
};
/** BillingInfo represents billing/company information for a workspace. */
export type BillingInfo = {
    __typename?: 'BillingInfo';
    address?: Maybe<Scalars['String']['output']>;
    billingEmail?: Maybe<Scalars['String']['output']>;
    createdAt: Scalars['DateTime']['output'];
    id: Scalars['Int']['output'];
    name?: Maybe<Scalars['String']['output']>;
    updatedAt?: Maybe<Scalars['DateTime']['output']>;
    workspaceId: Scalars['Int']['output'];
};
/** BillingInfoInput is an input for the billingInfo query. */
export type BillingInfoInput = {
    workspaceId: Scalars['Int']['input'];
};
/** CancelPendingPaymentInput is an input for cancelling a pending payment. */
export type CancelPendingPaymentInput = {
    id: Scalars['Int']['input'];
    workspaceId: Scalars['Int']['input'];
};
/** CancelPendingPaymentResult represents the result of cancelling a pending payment. */
export type CancelPendingPaymentResult = {
    __typename?: 'CancelPendingPaymentResult';
    failureReason?: Maybe<Scalars['String']['output']>;
    id: Scalars['Int']['output'];
    status: PendingPaymentStatus;
};
/** CheckoutInput is an input for purchasing a new plan. */
export type CheckoutInput = {
    paymentMethod?: InputMaybe<Scalars['String']['input']>;
    planType: PlanType;
    term: Term;
    turnstile?: InputMaybe<Scalars['String']['input']>;
    workspaceId: Scalars['Int']['input'];
};
/** CheckoutResult represents the result of a checkout. */
export type CheckoutResult = {
    __typename?: 'CheckoutResult';
    amount?: Maybe<Scalars['Float']['output']>;
    paymentRequired: Scalars['Boolean']['output'];
    pendingPaymentId?: Maybe<Scalars['Int']['output']>;
    planId?: Maybe<Scalars['Int']['output']>;
    stripeClientSecret?: Maybe<Scalars['String']['output']>;
    stripePaymentIntent?: Maybe<Scalars['String']['output']>;
    stripePaymentMethod?: Maybe<Scalars['String']['output']>;
    transactionId?: Maybe<Scalars['Int']['output']>;
};
/**
 * ErrorCode is an enum for the error codes.
 * - UNAUTHENTICATED: The user is not authenticated.
 * - FILE_UPLOAD_ERROR: a file upload error.
 * - FORBIDDEN: The user is forbidden to access the resource.
 * - FILE_NOT_FOUND: The file not found.
 * - RATE_LIMIT_ERROR: The rate limit error.
 */
export declare const ErrorCode: {
    readonly FILE_NOT_FOUND: "FILE_NOT_FOUND";
    readonly FILE_UPLOAD_ERROR: "FILE_UPLOAD_ERROR";
    readonly FORBIDDEN: "FORBIDDEN";
    readonly RATE_LIMIT_ERROR: "RATE_LIMIT_ERROR";
    readonly UNAUTHENTICATED: "UNAUTHENTICATED";
};
export type ErrorCode = typeof ErrorCode[keyof typeof ErrorCode];
export type Mutation = {
    __typename?: 'Mutation';
    /** Cancel a pending payment (only works if status is pending). */
    cancelPendingPayment: CancelPendingPaymentResult;
    /** Purchase a new plan (checkout). */
    checkout: CheckoutResult;
    /** Pause the subscription. */
    pauseSubscription: SubscriptionPlan;
    /** Create a Polar-hosted checkout session for purchasing a plan. */
    polarCheckout: PolarCheckoutResult;
    /** Create a Polar customer portal session for subscription management. */
    polarPortalSession: PolarPortalSessionResult;
    /** Renew the current subscription plan. */
    renew: CheckoutResult;
    /** Set up a new payment method (creates a setup intent). */
    setupPaymentMethod: SetupPaymentMethodResult;
    /** Create a Stripe-hosted checkout session for purchasing a plan. */
    stripeCheckout: StripeCheckoutResult;
    /** Create a Stripe billing portal session for subscription management. */
    stripePortalSession: StripePortalSessionResult;
    /** Unpause the subscription. */
    unpauseSubscription: SubscriptionPlan;
    /** Create or update billing info for a workspace. */
    updateBillingInfo: BillingInfo;
};
export type MutationCancelPendingPaymentArgs = {
    input: CancelPendingPaymentInput;
};
export type MutationCheckoutArgs = {
    input: CheckoutInput;
};
export type MutationPauseSubscriptionArgs = {
    input: PauseSubscriptionInput;
};
export type MutationPolarCheckoutArgs = {
    input: PolarCheckoutInput;
};
export type MutationPolarPortalSessionArgs = {
    input: PolarPortalSessionInput;
};
export type MutationRenewArgs = {
    input: RenewInput;
};
export type MutationSetupPaymentMethodArgs = {
    input: SetupPaymentMethodInput;
};
export type MutationStripeCheckoutArgs = {
    input: StripeCheckoutInput;
};
export type MutationStripePortalSessionArgs = {
    input: StripePortalSessionInput;
};
export type MutationUnpauseSubscriptionArgs = {
    input: UnpauseSubscriptionInput;
};
export type MutationUpdateBillingInfoArgs = {
    input: UpdateBillingInfoInput;
};
/** PageInfo is a type for the page info. It is used to paginate the results. */
export type PageInfo = {
    __typename?: 'PageInfo';
    /** The total count of the results. */
    count?: Maybe<Scalars['Int']['output']>;
    /** The cursor to the next page. It is used to fetch the next page. */
    endCursor?: Maybe<Scalars['Timestamp']['output']>;
    /** Indicates if there are more pages to fetch. */
    hasNextPage: Scalars['Boolean']['output'];
};
/** PageInfoInput is an input for the page info. It is used to paginate the results. */
export type PageInfoInput = {
    /**
     * Whether to return the total count of the results.
     * If true, the total count of the results will be returned in the response.
     */
    count?: InputMaybe<Scalars['Boolean']['input']>;
    /** The cursor to the next page. It is used to fetch the next page. */
    cursor?: InputMaybe<Scalars['Timestamp']['input']>;
    /** The limit of the results (Number of items per page, default is 100). */
    limit?: InputMaybe<Scalars['Int']['input']>;
    /** The query to filter the results. */
    query?: InputMaybe<Scalars['String']['input']>;
};
export type PauseSubscriptionInput = {
    durationInDays?: InputMaybe<Scalars['Int']['input']>;
    workspaceId: Scalars['Int']['input'];
};
/** PaymentMethod represents a payment method linked to a workspace. */
export type PaymentMethod = {
    __typename?: 'PaymentMethod';
    creationTime: Scalars['DateTime']['output'];
    id: Scalars['Int']['output'];
    paymentMethodType: Scalars['String']['output'];
    removed: Scalars['Boolean']['output'];
    stripeCard?: Maybe<StripeCard>;
    successfullyProcessed: Scalars['Boolean']['output'];
    updatedAt: Scalars['DateTime']['output'];
    userId: Scalars['String']['output'];
    workspaceId: Scalars['Int']['output'];
};
/** PaymentMethodInput is an input for retrieving a specific payment method. */
export type PaymentMethodInput = {
    id: Scalars['Int']['input'];
    workspaceId: Scalars['Int']['input'];
};
/** PaymentMethodsInput is an input for listing payment methods. */
export type PaymentMethodsInput = {
    workspaceId: Scalars['Int']['input'];
};
/** PendingPayment represents a pending payment. */
export type PendingPayment = {
    __typename?: 'PendingPayment';
    completedAt?: Maybe<Scalars['DateTime']['output']>;
    createdAt: Scalars['DateTime']['output'];
    failureReason?: Maybe<Scalars['String']['output']>;
    id: Scalars['Int']['output'];
    isRenewal: Scalars['Boolean']['output'];
    isSetupIntent: Scalars['Boolean']['output'];
    paymentMethodId?: Maybe<Scalars['Int']['output']>;
    planId?: Maybe<Scalars['Int']['output']>;
    status: PendingPaymentStatus;
    term: Scalars['String']['output'];
    transactionId?: Maybe<Scalars['Int']['output']>;
    updatedAt: Scalars['DateTime']['output'];
};
/** PendingPaymentInput is an input for retrieving a specific pending payment. */
export type PendingPaymentInput = {
    id: Scalars['Int']['input'];
    workspaceId: Scalars['Int']['input'];
};
/** PendingPaymentStatus represents the status of a pending payment. */
export declare const PendingPaymentStatus: {
    readonly FAILED: "failed";
    readonly PENDING: "pending";
    readonly PROCESSING: "processing";
    readonly SUCCESSFUL: "successful";
};
export type PendingPaymentStatus = typeof PendingPaymentStatus[keyof typeof PendingPaymentStatus];
/** PendingPaymentsInput is an input for listing pending payments. */
export type PendingPaymentsInput = {
    isRenewal?: InputMaybe<Scalars['Boolean']['input']>;
    paymentMethodId?: InputMaybe<Scalars['Int']['input']>;
    planId?: InputMaybe<Scalars['Int']['input']>;
    status?: InputMaybe<PendingPaymentStatus>;
    term?: InputMaybe<Scalars['String']['input']>;
    transactionId?: InputMaybe<Scalars['Int']['input']>;
    workspaceId: Scalars['Int']['input'];
};
/** Plan represents a subscription plan. */
export type Plan = {
    __typename?: 'Plan';
    aiEnabled: Scalars['Boolean']['output'];
    broadcastMessageCount: Scalars['Int']['output'];
    convCount: Scalars['Int']['output'];
    createdAt: Scalars['DateTime']['output'];
    deletedAt?: Maybe<Scalars['DateTime']['output']>;
    id: Scalars['Int']['output'];
    isBroadcast80PercentUsed?: Maybe<Scalars['Boolean']['output']>;
    isBroadcast100PercentUsed?: Maybe<Scalars['Boolean']['output']>;
    isBroadcast120PercentUsed?: Maybe<Scalars['Boolean']['output']>;
    isBroadcastUsed?: Maybe<Scalars['Boolean']['output']>;
    isConv80PercentUsed?: Maybe<Scalars['Boolean']['output']>;
    isConv100PercentUsed?: Maybe<Scalars['Boolean']['output']>;
    isConv120PercentUsed?: Maybe<Scalars['Boolean']['output']>;
    isConvUsed?: Maybe<Scalars['Boolean']['output']>;
    lastUseDate?: Maybe<Scalars['DateTime']['output']>;
    monthlyPrice: Scalars['Float']['output'];
    planType: PlanType;
    updatedAt: Scalars['DateTime']['output'];
    userCount: Scalars['Int']['output'];
    userId: Scalars['String']['output'];
    workspaceId?: Maybe<Scalars['Int']['output']>;
    yearlyPrice: Scalars['Float']['output'];
};
/** PlanInput is an input for retrieving a specific plan by ID. */
export type PlanInput = {
    id: Scalars['Int']['input'];
};
/** PlanPricing represents the pricing details for a plan. */
export type PlanPricing = {
    __typename?: 'PlanPricing';
    creditsAdded: Scalars['Float']['output'];
    creditsUsed: Scalars['Float']['output'];
    discountPercentage: Scalars['Float']['output'];
    nonDiscountedPrice: Scalars['Float']['output'];
    paidToday: Scalars['Float']['output'];
    price: Scalars['Float']['output'];
    promoDiscount: Scalars['Float']['output'];
};
/** PlanPricingInput is an input for retrieving plan pricing details. */
export type PlanPricingInput = {
    planType: PlanType;
    term: Term;
    workspaceId: Scalars['Int']['input'];
};
/** PlanType represents the type of subscription plan. */
export declare const PlanType: {
    readonly AUTOMATE: "automate";
    readonly AUTOMATE_MAX: "automate_max";
    readonly AUTOMATE_PLUS: "automate_plus";
    readonly BASIC: "basic";
    readonly BUSINESS: "business";
    readonly CUSTOM: "custom";
    readonly FREE: "free";
    readonly PREMIUM: "premium";
};
export type PlanType = typeof PlanType[keyof typeof PlanType];
/** PolarCheckoutInput is an input for creating a Polar-hosted checkout session. */
export type PolarCheckoutInput = {
    planType: PlanType;
    term: Term;
    workspaceId: Scalars['Int']['input'];
};
/** PolarCheckoutResult represents the result of creating a Polar checkout session. */
export type PolarCheckoutResult = {
    __typename?: 'PolarCheckoutResult';
    sessionId: Scalars['String']['output'];
    sessionUrl: Scalars['String']['output'];
};
/** PolarPortalSessionInput is an input for creating a Polar customer portal session. */
export type PolarPortalSessionInput = {
    workspaceId: Scalars['Int']['input'];
};
/** PolarPortalSessionResult represents the result of creating a Polar customer portal session. */
export type PolarPortalSessionResult = {
    __typename?: 'PolarPortalSessionResult';
    sessionId: Scalars['String']['output'];
    sessionUrl: Scalars['String']['output'];
};
/** PolarSessionLineItem represents a line item in a Polar checkout session. */
export type PolarSessionLineItem = {
    __typename?: 'PolarSessionLineItem';
    currency?: Maybe<Scalars['String']['output']>;
    description?: Maybe<Scalars['String']['output']>;
    priceId?: Maybe<Scalars['String']['output']>;
    productId?: Maybe<Scalars['String']['output']>;
    quantity?: Maybe<Scalars['Int']['output']>;
    unitAmount?: Maybe<Scalars['Float']['output']>;
};
/** PolarSessionMetadata represents the metadata attached to a Polar checkout session. */
export type PolarSessionMetadata = {
    __typename?: 'PolarSessionMetadata';
    planType?: Maybe<Scalars['String']['output']>;
    term?: Maybe<Scalars['String']['output']>;
    userId?: Maybe<Scalars['String']['output']>;
    workspaceId?: Maybe<Scalars['String']['output']>;
};
/** PolarSessionPlanInfo represents the plan information derived from a Polar checkout session. */
export type PolarSessionPlanInfo = {
    __typename?: 'PolarSessionPlanInfo';
    broadcastMessageCount?: Maybe<Scalars['Int']['output']>;
    convCount?: Maybe<Scalars['Int']['output']>;
    monthlyPrice?: Maybe<Scalars['Float']['output']>;
    planType?: Maybe<PlanType>;
    term?: Maybe<Term>;
    userCount?: Maybe<Scalars['Int']['output']>;
};
/** PolarSessionResult represents the result of verifying a Polar checkout session. */
export type PolarSessionResult = {
    __typename?: 'PolarSessionResult';
    customerId?: Maybe<Scalars['String']['output']>;
    lineItems: Array<PolarSessionLineItem>;
    metadata?: Maybe<PolarSessionMetadata>;
    paymentStatus: Scalars['String']['output'];
    plan?: Maybe<PolarSessionPlanInfo>;
    subscriptionId?: Maybe<Scalars['String']['output']>;
};
export type Query = {
    __typename?: 'Query';
    /** Get billing info for a workspace. */
    billingInfo?: Maybe<BillingInfo>;
    /** Get a specific payment method by ID. */
    paymentMethod?: Maybe<PaymentMethod>;
    /** List card payment methods for a workspace. */
    paymentMethods: Array<PaymentMethod>;
    /** Get a specific pending payment by ID. */
    pendingPayment?: Maybe<PendingPayment>;
    /** List pending payments for a workspace with optional filters. */
    pendingPayments: Array<PendingPayment>;
    /** Get a plan by ID. */
    plan?: Maybe<Plan>;
    /** Get pricing details for a plan type and term. */
    planPricing: PlanPricing;
    /** Get the current subscription for a workspace. */
    subscription: SubscriptionPlan;
    /** Get a transaction by ID. */
    transaction?: Maybe<Transaction>;
    /** List all transactions for a workspace. */
    transactions: Array<Transaction>;
    /** Verify a Polar checkout session by session ID. */
    verifyPolarSession: PolarSessionResult;
    /** Verify a Stripe checkout session by session ID. */
    verifyStripeSession: StripeSessionResult;
    /** Plan rows for a workspace (including historical snapshots), newest first. */
    workspacePlans: Array<Plan>;
};
export type QueryBillingInfoArgs = {
    input: BillingInfoInput;
};
export type QueryPaymentMethodArgs = {
    input: PaymentMethodInput;
};
export type QueryPaymentMethodsArgs = {
    input: PaymentMethodsInput;
};
export type QueryPendingPaymentArgs = {
    input: PendingPaymentInput;
};
export type QueryPendingPaymentsArgs = {
    input: PendingPaymentsInput;
};
export type QueryPlanArgs = {
    input: PlanInput;
};
export type QueryPlanPricingArgs = {
    input: PlanPricingInput;
};
export type QuerySubscriptionArgs = {
    input: SubscriptionInput;
};
export type QueryTransactionArgs = {
    input: TransactionInput;
};
export type QueryTransactionsArgs = {
    input: TransactionsInput;
};
export type QueryVerifyPolarSessionArgs = {
    input: VerifyPolarSessionInput;
};
export type QueryVerifyStripeSessionArgs = {
    input: VerifyStripeSessionInput;
};
export type QueryWorkspacePlansArgs = {
    input: WorkspacePlansInput;
};
/** RenewInput is an input for renewing a subscription plan. */
export type RenewInput = {
    paymentMethod?: InputMaybe<Scalars['String']['input']>;
    term: Term;
    turnstile?: InputMaybe<Scalars['String']['input']>;
    workspaceId: Scalars['Int']['input'];
};
/** SetupPaymentMethodInput is an input for setting up a new payment method. */
export type SetupPaymentMethodInput = {
    turnstile?: InputMaybe<Scalars['String']['input']>;
    workspaceId: Scalars['Int']['input'];
};
/** SetupPaymentMethodResult represents the result of setting up a payment method. */
export type SetupPaymentMethodResult = {
    __typename?: 'SetupPaymentMethodResult';
    pendingPaymentId: Scalars['Int']['output'];
    stripeClientSecret: Scalars['String']['output'];
    stripeSetupIntent: Scalars['String']['output'];
};
/** StripeCard represents a credit card stored in Stripe. */
export type StripeCard = {
    __typename?: 'StripeCard';
    brand?: Maybe<Scalars['String']['output']>;
    expireAt?: Maybe<Scalars['DateTime']['output']>;
    id: Scalars['Int']['output'];
    last4?: Maybe<Scalars['String']['output']>;
};
/** StripeCheckoutInput is an input for creating a Stripe-hosted checkout session. */
export type StripeCheckoutInput = {
    planType: PlanType;
    term: Term;
    workspaceId: Scalars['Int']['input'];
};
/** StripeCheckoutResult represents the result of creating a Stripe checkout session. */
export type StripeCheckoutResult = {
    __typename?: 'StripeCheckoutResult';
    sessionId: Scalars['String']['output'];
    sessionUrl: Scalars['String']['output'];
};
/** StripePortalSessionInput is an input for creating a Stripe billing portal session. */
export type StripePortalSessionInput = {
    workspaceId: Scalars['Int']['input'];
};
/** StripePortalSessionResult represents the result of creating a Stripe billing portal session. */
export type StripePortalSessionResult = {
    __typename?: 'StripePortalSessionResult';
    sessionId: Scalars['String']['output'];
    sessionUrl: Scalars['String']['output'];
};
/** StripeSessionLineItem represents a line item in a Stripe checkout session. */
export type StripeSessionLineItem = {
    __typename?: 'StripeSessionLineItem';
    currency?: Maybe<Scalars['String']['output']>;
    description?: Maybe<Scalars['String']['output']>;
    priceId?: Maybe<Scalars['String']['output']>;
    productId?: Maybe<Scalars['String']['output']>;
    quantity?: Maybe<Scalars['Int']['output']>;
    unitAmount?: Maybe<Scalars['Float']['output']>;
};
/** StripeSessionMetadata represents the metadata attached to a Stripe checkout session. */
export type StripeSessionMetadata = {
    __typename?: 'StripeSessionMetadata';
    planType?: Maybe<Scalars['String']['output']>;
    term?: Maybe<Scalars['String']['output']>;
    userId?: Maybe<Scalars['String']['output']>;
    workspaceId?: Maybe<Scalars['String']['output']>;
};
/** StripeSessionPlanInfo represents the plan information derived from a Stripe checkout session. */
export type StripeSessionPlanInfo = {
    __typename?: 'StripeSessionPlanInfo';
    broadcastMessageCount?: Maybe<Scalars['Int']['output']>;
    convCount?: Maybe<Scalars['Int']['output']>;
    monthlyPrice?: Maybe<Scalars['Float']['output']>;
    planType?: Maybe<PlanType>;
    term?: Maybe<Term>;
    userCount?: Maybe<Scalars['Int']['output']>;
};
/** StripeSessionResult represents the result of verifying a Stripe checkout session. */
export type StripeSessionResult = {
    __typename?: 'StripeSessionResult';
    customerId?: Maybe<Scalars['String']['output']>;
    lineItems: Array<StripeSessionLineItem>;
    metadata?: Maybe<StripeSessionMetadata>;
    paymentStatus: Scalars['String']['output'];
    plan?: Maybe<StripeSessionPlanInfo>;
    subscriptionId?: Maybe<Scalars['String']['output']>;
};
/** SubscriptionInput is an input for the subscription query. */
export type SubscriptionInput = {
    workspaceId: Scalars['Int']['input'];
};
/** SubscriptionPlan represents a user's subscription to a plan. */
export type SubscriptionPlan = {
    __typename?: 'SubscriptionPlan';
    accountDiscountPercentage: Scalars['Int']['output'];
    accountManagerId?: Maybe<Scalars['Int']['output']>;
    createdAt: Scalars['DateTime']['output'];
    customizable: Scalars['Boolean']['output'];
    endDate: Scalars['DateTime']['output'];
    failedPaymentTimes: Scalars['Int']['output'];
    freeCredits: Scalars['Float']['output'];
    id: Scalars['Int']['output'];
    isBusiness: Scalars['Boolean']['output'];
    isUsed?: Maybe<Scalars['Boolean']['output']>;
    lastPausedDate?: Maybe<Scalars['DateTime']['output']>;
    paused: Scalars['Boolean']['output'];
    paymentMethodId?: Maybe<Scalars['Int']['output']>;
    plan?: Maybe<Plan>;
    planId: Scalars['Int']['output'];
    promoType?: Maybe<Scalars['String']['output']>;
    promoValue?: Maybe<Scalars['Float']['output']>;
    reactivationDate?: Maybe<Scalars['DateTime']['output']>;
    reactivationPeriodLeft?: Maybe<Scalars['BigInt']['output']>;
    renewalInProgress: Scalars['Boolean']['output'];
    renewalsPaid: Scalars['Int']['output'];
    startDate: Scalars['DateTime']['output'];
    status?: Maybe<SubscriptionStatus>;
    stripeCustomerId?: Maybe<Scalars['String']['output']>;
    stripePriceId?: Maybe<Scalars['String']['output']>;
    stripeSubscriptionId?: Maybe<Scalars['String']['output']>;
    term: Term;
    updatedAt: Scalars['DateTime']['output'];
    updatingPaymentTries: Scalars['Int']['output'];
    workspaceId: Scalars['Int']['output'];
};
/** SubscriptionStatus represents the current state of a subscription. */
export declare const SubscriptionStatus: {
    readonly ACTIVE: "active";
    readonly CANCELED: "canceled";
    readonly PAST_DUE: "past_due";
    readonly PAUSED: "paused";
    readonly TRIALING: "trialing";
    readonly UNPAID: "unpaid";
};
export type SubscriptionStatus = typeof SubscriptionStatus[keyof typeof SubscriptionStatus];
/** Term represents the subscription billing period. */
export declare const Term: {
    readonly MONTHLY: "monthly";
    readonly YEARLY: "yearly";
};
export type Term = typeof Term[keyof typeof Term];
/** Transaction represents a subscription transaction. */
export type Transaction = {
    __typename?: 'Transaction';
    amount: Scalars['Float']['output'];
    createdAt: Scalars['DateTime']['output'];
    creditsGained: Scalars['Float']['output'];
    creditsUsed: Scalars['Float']['output'];
    id: Scalars['Int']['output'];
    paymentMethodId?: Maybe<Scalars['Int']['output']>;
    reason: Scalars['String']['output'];
    refundAmount: Scalars['Float']['output'];
    refundDate?: Maybe<Scalars['DateTime']['output']>;
    refundId?: Maybe<Scalars['String']['output']>;
    status: Scalars['String']['output'];
    transactionId?: Maybe<Scalars['String']['output']>;
    updatedAt: Scalars['DateTime']['output'];
    userId?: Maybe<Scalars['String']['output']>;
    workspaceId: Scalars['Int']['output'];
};
export type TransactionInput = {
    id: Scalars['Int']['input'];
    workspaceId: Scalars['Int']['input'];
};
/** TransactionsInput is an input for querying transactions. */
export type TransactionsInput = {
    workspaceId: Scalars['Int']['input'];
};
export type UnpauseSubscriptionInput = {
    workspaceId: Scalars['Int']['input'];
};
/** UpdateBillingInfoInput is an input for updating billing info (creates or updates by workspace). */
export type UpdateBillingInfoInput = {
    address?: InputMaybe<Scalars['String']['input']>;
    billingEmail?: InputMaybe<Scalars['String']['input']>;
    name?: InputMaybe<Scalars['String']['input']>;
    workspaceId: Scalars['Int']['input'];
};
/** VerifyPolarSessionInput is an input for verifying a Polar checkout session. */
export type VerifyPolarSessionInput = {
    sessionId: Scalars['String']['input'];
    workspaceId: Scalars['Int']['input'];
};
/** VerifyStripeSessionInput is an input for verifying a Stripe checkout session. */
export type VerifyStripeSessionInput = {
    sessionId: Scalars['String']['input'];
    workspaceId: Scalars['Int']['input'];
};
export type WorkspacePlansInput = {
    workspaceId: Scalars['Int']['input'];
};
export type BillingInfoQueryVariables = Exact<{
    input: BillingInfoInput;
}>;
export type BillingInfoQuery = {
    __typename?: 'Query';
    billingInfo?: {
        __typename?: 'BillingInfo';
        id: number;
        workspaceId: number;
        name?: string | null;
        address?: string | null;
        billingEmail?: string | null;
        createdAt: any;
        updatedAt?: any | null;
    } | null;
};
export type CancelPendingPaymentMutationVariables = Exact<{
    input: CancelPendingPaymentInput;
}>;
export type CancelPendingPaymentMutation = {
    __typename?: 'Mutation';
    cancelPendingPayment: {
        __typename?: 'CancelPendingPaymentResult';
        id: number;
        status: PendingPaymentStatus;
        failureReason?: string | null;
    };
};
export type CheckoutMutationVariables = Exact<{
    input: CheckoutInput;
}>;
export type CheckoutMutation = {
    __typename?: 'Mutation';
    checkout: {
        __typename?: 'CheckoutResult';
        paymentRequired: boolean;
        planId?: number | null;
        transactionId?: number | null;
        amount?: number | null;
        pendingPaymentId?: number | null;
        stripeClientSecret?: string | null;
        stripePaymentIntent?: string | null;
        stripePaymentMethod?: string | null;
    };
};
export type PaymentMethodQueryVariables = Exact<{
    input: PaymentMethodInput;
}>;
export type PaymentMethodQuery = {
    __typename?: 'Query';
    paymentMethod?: {
        __typename?: 'PaymentMethod';
        id: number;
        userId: string;
        workspaceId: number;
        removed: boolean;
        successfullyProcessed: boolean;
        creationTime: any;
        updatedAt: any;
        paymentMethodType: string;
        stripeCard?: {
            __typename?: 'StripeCard';
            id: number;
            brand?: string | null;
            last4?: string | null;
            expireAt?: any | null;
        } | null;
    } | null;
};
export type PaymentMethodsQueryVariables = Exact<{
    input: PaymentMethodsInput;
}>;
export type PaymentMethodsQuery = {
    __typename?: 'Query';
    paymentMethods: Array<{
        __typename?: 'PaymentMethod';
        id: number;
        userId: string;
        workspaceId: number;
        removed: boolean;
        successfullyProcessed: boolean;
        creationTime: any;
        updatedAt: any;
        paymentMethodType: string;
        stripeCard?: {
            __typename?: 'StripeCard';
            id: number;
            brand?: string | null;
            last4?: string | null;
            expireAt?: any | null;
        } | null;
    }>;
};
export type PendingPaymentQueryVariables = Exact<{
    input: PendingPaymentInput;
}>;
export type PendingPaymentQuery = {
    __typename?: 'Query';
    pendingPayment?: {
        __typename?: 'PendingPayment';
        id: number;
        status: PendingPaymentStatus;
        failureReason?: string | null;
        paymentMethodId?: number | null;
        planId?: number | null;
        transactionId?: number | null;
        isSetupIntent: boolean;
        isRenewal: boolean;
        term: string;
        createdAt: any;
        updatedAt: any;
        completedAt?: any | null;
    } | null;
};
export type PendingPaymentsQueryVariables = Exact<{
    input: PendingPaymentsInput;
}>;
export type PendingPaymentsQuery = {
    __typename?: 'Query';
    pendingPayments: Array<{
        __typename?: 'PendingPayment';
        id: number;
        status: PendingPaymentStatus;
        failureReason?: string | null;
        paymentMethodId?: number | null;
        planId?: number | null;
        transactionId?: number | null;
        isSetupIntent: boolean;
        isRenewal: boolean;
        term: string;
        createdAt: any;
        updatedAt: any;
        completedAt?: any | null;
    }>;
};
export type PlanQueryVariables = Exact<{
    input: PlanInput;
}>;
export type PlanQuery = {
    __typename?: 'Query';
    plan?: {
        __typename?: 'Plan';
        id: number;
        userId: string;
        planType: PlanType;
        aiEnabled: boolean;
        convCount: number;
        broadcastMessageCount: number;
        userCount: number;
        monthlyPrice: number;
        yearlyPrice: number;
        isConvUsed?: boolean | null;
        isBroadcastUsed?: boolean | null;
        lastUseDate?: any | null;
        isConv80PercentUsed?: boolean | null;
        isConv100PercentUsed?: boolean | null;
        isConv120PercentUsed?: boolean | null;
        isBroadcast80PercentUsed?: boolean | null;
        isBroadcast100PercentUsed?: boolean | null;
        isBroadcast120PercentUsed?: boolean | null;
        createdAt: any;
        updatedAt: any;
        deletedAt?: any | null;
    } | null;
};
export type PlanPricingQueryVariables = Exact<{
    input: PlanPricingInput;
}>;
export type PlanPricingQuery = {
    __typename?: 'Query';
    planPricing: {
        __typename?: 'PlanPricing';
        discountPercentage: number;
        nonDiscountedPrice: number;
        price: number;
        paidToday: number;
        creditsAdded: number;
        creditsUsed: number;
        promoDiscount: number;
    };
};
export type PolarCheckoutMutationVariables = Exact<{
    input: PolarCheckoutInput;
}>;
export type PolarCheckoutMutation = {
    __typename?: 'Mutation';
    polarCheckout: {
        __typename?: 'PolarCheckoutResult';
        sessionId: string;
        sessionUrl: string;
    };
};
export type PolarPortalSessionMutationVariables = Exact<{
    input: PolarPortalSessionInput;
}>;
export type PolarPortalSessionMutation = {
    __typename?: 'Mutation';
    polarPortalSession: {
        __typename?: 'PolarPortalSessionResult';
        sessionId: string;
        sessionUrl: string;
    };
};
export type RenewMutationVariables = Exact<{
    input: RenewInput;
}>;
export type RenewMutation = {
    __typename?: 'Mutation';
    renew: {
        __typename?: 'CheckoutResult';
        paymentRequired: boolean;
        planId?: number | null;
        transactionId?: number | null;
        amount?: number | null;
        pendingPaymentId?: number | null;
        stripeClientSecret?: string | null;
        stripePaymentIntent?: string | null;
        stripePaymentMethod?: string | null;
    };
};
export type SetupPaymentMethodMutationVariables = Exact<{
    input: SetupPaymentMethodInput;
}>;
export type SetupPaymentMethodMutation = {
    __typename?: 'Mutation';
    setupPaymentMethod: {
        __typename?: 'SetupPaymentMethodResult';
        pendingPaymentId: number;
        stripeClientSecret: string;
        stripeSetupIntent: string;
    };
};
export type StripeCheckoutMutationVariables = Exact<{
    input: StripeCheckoutInput;
}>;
export type StripeCheckoutMutation = {
    __typename?: 'Mutation';
    stripeCheckout: {
        __typename?: 'StripeCheckoutResult';
        sessionId: string;
        sessionUrl: string;
    };
};
export type StripePortalSessionMutationVariables = Exact<{
    input: StripePortalSessionInput;
}>;
export type StripePortalSessionMutation = {
    __typename?: 'Mutation';
    stripePortalSession: {
        __typename?: 'StripePortalSessionResult';
        sessionId: string;
        sessionUrl: string;
    };
};
export type SubscriptionQueryVariables = Exact<{
    input: SubscriptionInput;
}>;
export type SubscriptionQuery = {
    __typename?: 'Query';
    subscription: {
        __typename?: 'SubscriptionPlan';
        id: number;
        workspaceId: number;
        stripeCustomerId?: string | null;
        freeCredits: number;
        planId: number;
        term: Term;
        startDate: any;
        endDate: any;
        paused: boolean;
        reactivationDate?: any | null;
        reactivationPeriodLeft?: any | null;
        lastPausedDate?: any | null;
        paymentMethodId?: number | null;
        updatingPaymentTries: number;
        renewalsPaid: number;
        renewalInProgress: boolean;
        failedPaymentTimes: number;
        accountDiscountPercentage: number;
        customizable: boolean;
        accountManagerId?: number | null;
        promoType?: string | null;
        promoValue?: number | null;
        isUsed?: boolean | null;
        createdAt: any;
        updatedAt: any;
        plan?: {
            __typename?: 'Plan';
            id: number;
            userId: string;
            planType: PlanType;
            aiEnabled: boolean;
            convCount: number;
            broadcastMessageCount: number;
            userCount: number;
            monthlyPrice: number;
            yearlyPrice: number;
            isConvUsed?: boolean | null;
            isBroadcastUsed?: boolean | null;
            lastUseDate?: any | null;
            isConv80PercentUsed?: boolean | null;
            isConv100PercentUsed?: boolean | null;
            isConv120PercentUsed?: boolean | null;
            isBroadcast80PercentUsed?: boolean | null;
            isBroadcast100PercentUsed?: boolean | null;
            isBroadcast120PercentUsed?: boolean | null;
            createdAt: any;
            updatedAt: any;
            deletedAt?: any | null;
        } | null;
    };
};
export type TransactionQueryVariables = Exact<{
    input: TransactionInput;
}>;
export type TransactionQuery = {
    __typename?: 'Query';
    transaction?: {
        __typename?: 'Transaction';
        id: number;
        userId?: string | null;
        workspaceId: number;
        status: string;
        paymentMethodId?: number | null;
        reason: string;
        amount: number;
        creditsUsed: number;
        creditsGained: number;
        refundAmount: number;
        refundDate?: any | null;
        transactionId?: string | null;
        refundId?: string | null;
        createdAt: any;
        updatedAt: any;
    } | null;
};
export type TransactionsQueryVariables = Exact<{
    input: TransactionsInput;
}>;
export type TransactionsQuery = {
    __typename?: 'Query';
    transactions: Array<{
        __typename?: 'Transaction';
        id: number;
        userId?: string | null;
        workspaceId: number;
        status: string;
        paymentMethodId?: number | null;
        reason: string;
        amount: number;
        creditsUsed: number;
        creditsGained: number;
        refundAmount: number;
        refundDate?: any | null;
        transactionId?: string | null;
        refundId?: string | null;
        createdAt: any;
        updatedAt: any;
    }>;
};
export type UpdateBillingInfoMutationVariables = Exact<{
    input: UpdateBillingInfoInput;
}>;
export type UpdateBillingInfoMutation = {
    __typename?: 'Mutation';
    updateBillingInfo: {
        __typename?: 'BillingInfo';
        id: number;
        workspaceId: number;
        name?: string | null;
        address?: string | null;
        billingEmail?: string | null;
        createdAt: any;
        updatedAt?: any | null;
    };
};
export type VerifyPolarSessionQueryVariables = Exact<{
    input: VerifyPolarSessionInput;
}>;
export type VerifyPolarSessionQuery = {
    __typename?: 'Query';
    verifyPolarSession: {
        __typename?: 'PolarSessionResult';
        customerId?: string | null;
        subscriptionId?: string | null;
        paymentStatus: string;
        metadata?: {
            __typename?: 'PolarSessionMetadata';
            workspaceId?: string | null;
            planType?: string | null;
            term?: string | null;
            userId?: string | null;
        } | null;
        lineItems: Array<{
            __typename?: 'PolarSessionLineItem';
            priceId?: string | null;
            productId?: string | null;
            description?: string | null;
            quantity?: number | null;
            unitAmount?: number | null;
            currency?: string | null;
        }>;
        plan?: {
            __typename?: 'PolarSessionPlanInfo';
            planType?: PlanType | null;
            term?: Term | null;
            convCount?: number | null;
            broadcastMessageCount?: number | null;
            userCount?: number | null;
            monthlyPrice?: number | null;
        } | null;
    };
};
export type VerifyStripeSessionQueryVariables = Exact<{
    input: VerifyStripeSessionInput;
}>;
export type VerifyStripeSessionQuery = {
    __typename?: 'Query';
    verifyStripeSession: {
        __typename?: 'StripeSessionResult';
        customerId?: string | null;
        subscriptionId?: string | null;
        paymentStatus: string;
        metadata?: {
            __typename?: 'StripeSessionMetadata';
            workspaceId?: string | null;
            planType?: string | null;
            term?: string | null;
            userId?: string | null;
        } | null;
        lineItems: Array<{
            __typename?: 'StripeSessionLineItem';
            priceId?: string | null;
            productId?: string | null;
            description?: string | null;
            quantity?: number | null;
            unitAmount?: number | null;
            currency?: string | null;
        }>;
        plan?: {
            __typename?: 'StripeSessionPlanInfo';
            planType?: PlanType | null;
            term?: Term | null;
            convCount?: number | null;
            broadcastMessageCount?: number | null;
            userCount?: number | null;
            monthlyPrice?: number | null;
        } | null;
    };
};
export declare const BillingInfoDocument: Apollo.DocumentNode;
/**
 * __useBillingInfoQuery__
 *
 * To run a query within a React component, call `useBillingInfoQuery` and pass it any options that fit your needs.
 * When your component renders, `useBillingInfoQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useBillingInfoQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useBillingInfoQuery(baseOptions: Apollo.QueryHookOptions<BillingInfoQuery, BillingInfoQueryVariables> & ({
    variables: BillingInfoQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): Apollo.QueryResult<BillingInfoQuery, Exact<{
    input: BillingInfoInput;
}>>;
export declare function useBillingInfoLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BillingInfoQuery, BillingInfoQueryVariables>): Apollo.LazyQueryResultTuple<BillingInfoQuery, Exact<{
    input: BillingInfoInput;
}>>;
export declare function useBillingInfoSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BillingInfoQuery, BillingInfoQueryVariables>): Apollo.UseSuspenseQueryResult<BillingInfoQuery | undefined, Exact<{
    input: BillingInfoInput;
}>>;
export type BillingInfoQueryHookResult = ReturnType<typeof useBillingInfoQuery>;
export type BillingInfoLazyQueryHookResult = ReturnType<typeof useBillingInfoLazyQuery>;
export type BillingInfoSuspenseQueryHookResult = ReturnType<typeof useBillingInfoSuspenseQuery>;
export type BillingInfoQueryResult = Apollo.QueryResult<BillingInfoQuery, BillingInfoQueryVariables>;
export declare function refetchBillingInfoQuery(variables: BillingInfoQueryVariables): {
    query: Apollo.DocumentNode;
    variables: Exact<{
        input: BillingInfoInput;
    }>;
};
export declare const CancelPendingPaymentDocument: Apollo.DocumentNode;
export type CancelPendingPaymentMutationFn = Apollo.MutationFunction<CancelPendingPaymentMutation, CancelPendingPaymentMutationVariables>;
/**
 * __useCancelPendingPaymentMutation__
 *
 * To run a mutation, you first call `useCancelPendingPaymentMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCancelPendingPaymentMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [cancelPendingPaymentMutation, { data, loading, error }] = useCancelPendingPaymentMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCancelPendingPaymentMutation(baseOptions?: Apollo.MutationHookOptions<CancelPendingPaymentMutation, CancelPendingPaymentMutationVariables>): Apollo.MutationTuple<CancelPendingPaymentMutation, Exact<{
    input: CancelPendingPaymentInput;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type CancelPendingPaymentMutationHookResult = ReturnType<typeof useCancelPendingPaymentMutation>;
export type CancelPendingPaymentMutationResult = Apollo.MutationResult<CancelPendingPaymentMutation>;
export type CancelPendingPaymentMutationOptions = Apollo.BaseMutationOptions<CancelPendingPaymentMutation, CancelPendingPaymentMutationVariables>;
export declare const CheckoutDocument: Apollo.DocumentNode;
export type CheckoutMutationFn = Apollo.MutationFunction<CheckoutMutation, CheckoutMutationVariables>;
/**
 * __useCheckoutMutation__
 *
 * To run a mutation, you first call `useCheckoutMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useCheckoutMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [checkoutMutation, { data, loading, error }] = useCheckoutMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useCheckoutMutation(baseOptions?: Apollo.MutationHookOptions<CheckoutMutation, CheckoutMutationVariables>): Apollo.MutationTuple<CheckoutMutation, Exact<{
    input: CheckoutInput;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type CheckoutMutationHookResult = ReturnType<typeof useCheckoutMutation>;
export type CheckoutMutationResult = Apollo.MutationResult<CheckoutMutation>;
export type CheckoutMutationOptions = Apollo.BaseMutationOptions<CheckoutMutation, CheckoutMutationVariables>;
export declare const PaymentMethodDocument: Apollo.DocumentNode;
/**
 * __usePaymentMethodQuery__
 *
 * To run a query within a React component, call `usePaymentMethodQuery` and pass it any options that fit your needs.
 * When your component renders, `usePaymentMethodQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = usePaymentMethodQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function usePaymentMethodQuery(baseOptions: Apollo.QueryHookOptions<PaymentMethodQuery, PaymentMethodQueryVariables> & ({
    variables: PaymentMethodQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): Apollo.QueryResult<PaymentMethodQuery, Exact<{
    input: PaymentMethodInput;
}>>;
export declare function usePaymentMethodLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PaymentMethodQuery, PaymentMethodQueryVariables>): Apollo.LazyQueryResultTuple<PaymentMethodQuery, Exact<{
    input: PaymentMethodInput;
}>>;
export declare function usePaymentMethodSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PaymentMethodQuery, PaymentMethodQueryVariables>): Apollo.UseSuspenseQueryResult<PaymentMethodQuery | undefined, Exact<{
    input: PaymentMethodInput;
}>>;
export type PaymentMethodQueryHookResult = ReturnType<typeof usePaymentMethodQuery>;
export type PaymentMethodLazyQueryHookResult = ReturnType<typeof usePaymentMethodLazyQuery>;
export type PaymentMethodSuspenseQueryHookResult = ReturnType<typeof usePaymentMethodSuspenseQuery>;
export type PaymentMethodQueryResult = Apollo.QueryResult<PaymentMethodQuery, PaymentMethodQueryVariables>;
export declare function refetchPaymentMethodQuery(variables: PaymentMethodQueryVariables): {
    query: Apollo.DocumentNode;
    variables: Exact<{
        input: PaymentMethodInput;
    }>;
};
export declare const PaymentMethodsDocument: Apollo.DocumentNode;
/**
 * __usePaymentMethodsQuery__
 *
 * To run a query within a React component, call `usePaymentMethodsQuery` and pass it any options that fit your needs.
 * When your component renders, `usePaymentMethodsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = usePaymentMethodsQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function usePaymentMethodsQuery(baseOptions: Apollo.QueryHookOptions<PaymentMethodsQuery, PaymentMethodsQueryVariables> & ({
    variables: PaymentMethodsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): Apollo.QueryResult<PaymentMethodsQuery, Exact<{
    input: PaymentMethodsInput;
}>>;
export declare function usePaymentMethodsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PaymentMethodsQuery, PaymentMethodsQueryVariables>): Apollo.LazyQueryResultTuple<PaymentMethodsQuery, Exact<{
    input: PaymentMethodsInput;
}>>;
export declare function usePaymentMethodsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PaymentMethodsQuery, PaymentMethodsQueryVariables>): Apollo.UseSuspenseQueryResult<PaymentMethodsQuery | undefined, Exact<{
    input: PaymentMethodsInput;
}>>;
export type PaymentMethodsQueryHookResult = ReturnType<typeof usePaymentMethodsQuery>;
export type PaymentMethodsLazyQueryHookResult = ReturnType<typeof usePaymentMethodsLazyQuery>;
export type PaymentMethodsSuspenseQueryHookResult = ReturnType<typeof usePaymentMethodsSuspenseQuery>;
export type PaymentMethodsQueryResult = Apollo.QueryResult<PaymentMethodsQuery, PaymentMethodsQueryVariables>;
export declare function refetchPaymentMethodsQuery(variables: PaymentMethodsQueryVariables): {
    query: Apollo.DocumentNode;
    variables: Exact<{
        input: PaymentMethodsInput;
    }>;
};
export declare const PendingPaymentDocument: Apollo.DocumentNode;
/**
 * __usePendingPaymentQuery__
 *
 * To run a query within a React component, call `usePendingPaymentQuery` and pass it any options that fit your needs.
 * When your component renders, `usePendingPaymentQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = usePendingPaymentQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function usePendingPaymentQuery(baseOptions: Apollo.QueryHookOptions<PendingPaymentQuery, PendingPaymentQueryVariables> & ({
    variables: PendingPaymentQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): Apollo.QueryResult<PendingPaymentQuery, Exact<{
    input: PendingPaymentInput;
}>>;
export declare function usePendingPaymentLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PendingPaymentQuery, PendingPaymentQueryVariables>): Apollo.LazyQueryResultTuple<PendingPaymentQuery, Exact<{
    input: PendingPaymentInput;
}>>;
export declare function usePendingPaymentSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PendingPaymentQuery, PendingPaymentQueryVariables>): Apollo.UseSuspenseQueryResult<PendingPaymentQuery | undefined, Exact<{
    input: PendingPaymentInput;
}>>;
export type PendingPaymentQueryHookResult = ReturnType<typeof usePendingPaymentQuery>;
export type PendingPaymentLazyQueryHookResult = ReturnType<typeof usePendingPaymentLazyQuery>;
export type PendingPaymentSuspenseQueryHookResult = ReturnType<typeof usePendingPaymentSuspenseQuery>;
export type PendingPaymentQueryResult = Apollo.QueryResult<PendingPaymentQuery, PendingPaymentQueryVariables>;
export declare function refetchPendingPaymentQuery(variables: PendingPaymentQueryVariables): {
    query: Apollo.DocumentNode;
    variables: Exact<{
        input: PendingPaymentInput;
    }>;
};
export declare const PendingPaymentsDocument: Apollo.DocumentNode;
/**
 * __usePendingPaymentsQuery__
 *
 * To run a query within a React component, call `usePendingPaymentsQuery` and pass it any options that fit your needs.
 * When your component renders, `usePendingPaymentsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = usePendingPaymentsQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function usePendingPaymentsQuery(baseOptions: Apollo.QueryHookOptions<PendingPaymentsQuery, PendingPaymentsQueryVariables> & ({
    variables: PendingPaymentsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): Apollo.QueryResult<PendingPaymentsQuery, Exact<{
    input: PendingPaymentsInput;
}>>;
export declare function usePendingPaymentsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PendingPaymentsQuery, PendingPaymentsQueryVariables>): Apollo.LazyQueryResultTuple<PendingPaymentsQuery, Exact<{
    input: PendingPaymentsInput;
}>>;
export declare function usePendingPaymentsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PendingPaymentsQuery, PendingPaymentsQueryVariables>): Apollo.UseSuspenseQueryResult<PendingPaymentsQuery | undefined, Exact<{
    input: PendingPaymentsInput;
}>>;
export type PendingPaymentsQueryHookResult = ReturnType<typeof usePendingPaymentsQuery>;
export type PendingPaymentsLazyQueryHookResult = ReturnType<typeof usePendingPaymentsLazyQuery>;
export type PendingPaymentsSuspenseQueryHookResult = ReturnType<typeof usePendingPaymentsSuspenseQuery>;
export type PendingPaymentsQueryResult = Apollo.QueryResult<PendingPaymentsQuery, PendingPaymentsQueryVariables>;
export declare function refetchPendingPaymentsQuery(variables: PendingPaymentsQueryVariables): {
    query: Apollo.DocumentNode;
    variables: Exact<{
        input: PendingPaymentsInput;
    }>;
};
export declare const PlanDocument: Apollo.DocumentNode;
/**
 * __usePlanQuery__
 *
 * To run a query within a React component, call `usePlanQuery` and pass it any options that fit your needs.
 * When your component renders, `usePlanQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = usePlanQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function usePlanQuery(baseOptions: Apollo.QueryHookOptions<PlanQuery, PlanQueryVariables> & ({
    variables: PlanQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): Apollo.QueryResult<PlanQuery, Exact<{
    input: PlanInput;
}>>;
export declare function usePlanLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PlanQuery, PlanQueryVariables>): Apollo.LazyQueryResultTuple<PlanQuery, Exact<{
    input: PlanInput;
}>>;
export declare function usePlanSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PlanQuery, PlanQueryVariables>): Apollo.UseSuspenseQueryResult<PlanQuery | undefined, Exact<{
    input: PlanInput;
}>>;
export type PlanQueryHookResult = ReturnType<typeof usePlanQuery>;
export type PlanLazyQueryHookResult = ReturnType<typeof usePlanLazyQuery>;
export type PlanSuspenseQueryHookResult = ReturnType<typeof usePlanSuspenseQuery>;
export type PlanQueryResult = Apollo.QueryResult<PlanQuery, PlanQueryVariables>;
export declare function refetchPlanQuery(variables: PlanQueryVariables): {
    query: Apollo.DocumentNode;
    variables: Exact<{
        input: PlanInput;
    }>;
};
export declare const PlanPricingDocument: Apollo.DocumentNode;
/**
 * __usePlanPricingQuery__
 *
 * To run a query within a React component, call `usePlanPricingQuery` and pass it any options that fit your needs.
 * When your component renders, `usePlanPricingQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = usePlanPricingQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function usePlanPricingQuery(baseOptions: Apollo.QueryHookOptions<PlanPricingQuery, PlanPricingQueryVariables> & ({
    variables: PlanPricingQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): Apollo.QueryResult<PlanPricingQuery, Exact<{
    input: PlanPricingInput;
}>>;
export declare function usePlanPricingLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PlanPricingQuery, PlanPricingQueryVariables>): Apollo.LazyQueryResultTuple<PlanPricingQuery, Exact<{
    input: PlanPricingInput;
}>>;
export declare function usePlanPricingSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<PlanPricingQuery, PlanPricingQueryVariables>): Apollo.UseSuspenseQueryResult<PlanPricingQuery | undefined, Exact<{
    input: PlanPricingInput;
}>>;
export type PlanPricingQueryHookResult = ReturnType<typeof usePlanPricingQuery>;
export type PlanPricingLazyQueryHookResult = ReturnType<typeof usePlanPricingLazyQuery>;
export type PlanPricingSuspenseQueryHookResult = ReturnType<typeof usePlanPricingSuspenseQuery>;
export type PlanPricingQueryResult = Apollo.QueryResult<PlanPricingQuery, PlanPricingQueryVariables>;
export declare function refetchPlanPricingQuery(variables: PlanPricingQueryVariables): {
    query: Apollo.DocumentNode;
    variables: Exact<{
        input: PlanPricingInput;
    }>;
};
export declare const PolarCheckoutDocument: Apollo.DocumentNode;
export type PolarCheckoutMutationFn = Apollo.MutationFunction<PolarCheckoutMutation, PolarCheckoutMutationVariables>;
/**
 * __usePolarCheckoutMutation__
 *
 * To run a mutation, you first call `usePolarCheckoutMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `usePolarCheckoutMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [polarCheckoutMutation, { data, loading, error }] = usePolarCheckoutMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function usePolarCheckoutMutation(baseOptions?: Apollo.MutationHookOptions<PolarCheckoutMutation, PolarCheckoutMutationVariables>): Apollo.MutationTuple<PolarCheckoutMutation, Exact<{
    input: PolarCheckoutInput;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type PolarCheckoutMutationHookResult = ReturnType<typeof usePolarCheckoutMutation>;
export type PolarCheckoutMutationResult = Apollo.MutationResult<PolarCheckoutMutation>;
export type PolarCheckoutMutationOptions = Apollo.BaseMutationOptions<PolarCheckoutMutation, PolarCheckoutMutationVariables>;
export declare const PolarPortalSessionDocument: Apollo.DocumentNode;
export type PolarPortalSessionMutationFn = Apollo.MutationFunction<PolarPortalSessionMutation, PolarPortalSessionMutationVariables>;
/**
 * __usePolarPortalSessionMutation__
 *
 * To run a mutation, you first call `usePolarPortalSessionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `usePolarPortalSessionMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [polarPortalSessionMutation, { data, loading, error }] = usePolarPortalSessionMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function usePolarPortalSessionMutation(baseOptions?: Apollo.MutationHookOptions<PolarPortalSessionMutation, PolarPortalSessionMutationVariables>): Apollo.MutationTuple<PolarPortalSessionMutation, Exact<{
    input: PolarPortalSessionInput;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type PolarPortalSessionMutationHookResult = ReturnType<typeof usePolarPortalSessionMutation>;
export type PolarPortalSessionMutationResult = Apollo.MutationResult<PolarPortalSessionMutation>;
export type PolarPortalSessionMutationOptions = Apollo.BaseMutationOptions<PolarPortalSessionMutation, PolarPortalSessionMutationVariables>;
export declare const RenewDocument: Apollo.DocumentNode;
export type RenewMutationFn = Apollo.MutationFunction<RenewMutation, RenewMutationVariables>;
/**
 * __useRenewMutation__
 *
 * To run a mutation, you first call `useRenewMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useRenewMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [renewMutation, { data, loading, error }] = useRenewMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useRenewMutation(baseOptions?: Apollo.MutationHookOptions<RenewMutation, RenewMutationVariables>): Apollo.MutationTuple<RenewMutation, Exact<{
    input: RenewInput;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type RenewMutationHookResult = ReturnType<typeof useRenewMutation>;
export type RenewMutationResult = Apollo.MutationResult<RenewMutation>;
export type RenewMutationOptions = Apollo.BaseMutationOptions<RenewMutation, RenewMutationVariables>;
export declare const SetupPaymentMethodDocument: Apollo.DocumentNode;
export type SetupPaymentMethodMutationFn = Apollo.MutationFunction<SetupPaymentMethodMutation, SetupPaymentMethodMutationVariables>;
/**
 * __useSetupPaymentMethodMutation__
 *
 * To run a mutation, you first call `useSetupPaymentMethodMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useSetupPaymentMethodMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [setupPaymentMethodMutation, { data, loading, error }] = useSetupPaymentMethodMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useSetupPaymentMethodMutation(baseOptions?: Apollo.MutationHookOptions<SetupPaymentMethodMutation, SetupPaymentMethodMutationVariables>): Apollo.MutationTuple<SetupPaymentMethodMutation, Exact<{
    input: SetupPaymentMethodInput;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type SetupPaymentMethodMutationHookResult = ReturnType<typeof useSetupPaymentMethodMutation>;
export type SetupPaymentMethodMutationResult = Apollo.MutationResult<SetupPaymentMethodMutation>;
export type SetupPaymentMethodMutationOptions = Apollo.BaseMutationOptions<SetupPaymentMethodMutation, SetupPaymentMethodMutationVariables>;
export declare const StripeCheckoutDocument: Apollo.DocumentNode;
export type StripeCheckoutMutationFn = Apollo.MutationFunction<StripeCheckoutMutation, StripeCheckoutMutationVariables>;
/**
 * __useStripeCheckoutMutation__
 *
 * To run a mutation, you first call `useStripeCheckoutMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useStripeCheckoutMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [stripeCheckoutMutation, { data, loading, error }] = useStripeCheckoutMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useStripeCheckoutMutation(baseOptions?: Apollo.MutationHookOptions<StripeCheckoutMutation, StripeCheckoutMutationVariables>): Apollo.MutationTuple<StripeCheckoutMutation, Exact<{
    input: StripeCheckoutInput;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type StripeCheckoutMutationHookResult = ReturnType<typeof useStripeCheckoutMutation>;
export type StripeCheckoutMutationResult = Apollo.MutationResult<StripeCheckoutMutation>;
export type StripeCheckoutMutationOptions = Apollo.BaseMutationOptions<StripeCheckoutMutation, StripeCheckoutMutationVariables>;
export declare const StripePortalSessionDocument: Apollo.DocumentNode;
export type StripePortalSessionMutationFn = Apollo.MutationFunction<StripePortalSessionMutation, StripePortalSessionMutationVariables>;
/**
 * __useStripePortalSessionMutation__
 *
 * To run a mutation, you first call `useStripePortalSessionMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useStripePortalSessionMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [stripePortalSessionMutation, { data, loading, error }] = useStripePortalSessionMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useStripePortalSessionMutation(baseOptions?: Apollo.MutationHookOptions<StripePortalSessionMutation, StripePortalSessionMutationVariables>): Apollo.MutationTuple<StripePortalSessionMutation, Exact<{
    input: StripePortalSessionInput;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type StripePortalSessionMutationHookResult = ReturnType<typeof useStripePortalSessionMutation>;
export type StripePortalSessionMutationResult = Apollo.MutationResult<StripePortalSessionMutation>;
export type StripePortalSessionMutationOptions = Apollo.BaseMutationOptions<StripePortalSessionMutation, StripePortalSessionMutationVariables>;
export declare const SubscriptionDocument: Apollo.DocumentNode;
/**
 * __useSubscriptionQuery__
 *
 * To run a query within a React component, call `useSubscriptionQuery` and pass it any options that fit your needs.
 * When your component renders, `useSubscriptionQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useSubscriptionQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useSubscriptionQuery(baseOptions: Apollo.QueryHookOptions<SubscriptionQuery, SubscriptionQueryVariables> & ({
    variables: SubscriptionQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): Apollo.QueryResult<SubscriptionQuery, Exact<{
    input: SubscriptionInput;
}>>;
export declare function useSubscriptionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SubscriptionQuery, SubscriptionQueryVariables>): Apollo.LazyQueryResultTuple<SubscriptionQuery, Exact<{
    input: SubscriptionInput;
}>>;
export declare function useSubscriptionSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<SubscriptionQuery, SubscriptionQueryVariables>): Apollo.UseSuspenseQueryResult<SubscriptionQuery | undefined, Exact<{
    input: SubscriptionInput;
}>>;
export type SubscriptionQueryHookResult = ReturnType<typeof useSubscriptionQuery>;
export type SubscriptionLazyQueryHookResult = ReturnType<typeof useSubscriptionLazyQuery>;
export type SubscriptionSuspenseQueryHookResult = ReturnType<typeof useSubscriptionSuspenseQuery>;
export type SubscriptionQueryResult = Apollo.QueryResult<SubscriptionQuery, SubscriptionQueryVariables>;
export declare function refetchSubscriptionQuery(variables: SubscriptionQueryVariables): {
    query: Apollo.DocumentNode;
    variables: Exact<{
        input: SubscriptionInput;
    }>;
};
export declare const TransactionDocument: Apollo.DocumentNode;
/**
 * __useTransactionQuery__
 *
 * To run a query within a React component, call `useTransactionQuery` and pass it any options that fit your needs.
 * When your component renders, `useTransactionQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useTransactionQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useTransactionQuery(baseOptions: Apollo.QueryHookOptions<TransactionQuery, TransactionQueryVariables> & ({
    variables: TransactionQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): Apollo.QueryResult<TransactionQuery, Exact<{
    input: TransactionInput;
}>>;
export declare function useTransactionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TransactionQuery, TransactionQueryVariables>): Apollo.LazyQueryResultTuple<TransactionQuery, Exact<{
    input: TransactionInput;
}>>;
export declare function useTransactionSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<TransactionQuery, TransactionQueryVariables>): Apollo.UseSuspenseQueryResult<TransactionQuery | undefined, Exact<{
    input: TransactionInput;
}>>;
export type TransactionQueryHookResult = ReturnType<typeof useTransactionQuery>;
export type TransactionLazyQueryHookResult = ReturnType<typeof useTransactionLazyQuery>;
export type TransactionSuspenseQueryHookResult = ReturnType<typeof useTransactionSuspenseQuery>;
export type TransactionQueryResult = Apollo.QueryResult<TransactionQuery, TransactionQueryVariables>;
export declare function refetchTransactionQuery(variables: TransactionQueryVariables): {
    query: Apollo.DocumentNode;
    variables: Exact<{
        input: TransactionInput;
    }>;
};
export declare const TransactionsDocument: Apollo.DocumentNode;
/**
 * __useTransactionsQuery__
 *
 * To run a query within a React component, call `useTransactionsQuery` and pass it any options that fit your needs.
 * When your component renders, `useTransactionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useTransactionsQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useTransactionsQuery(baseOptions: Apollo.QueryHookOptions<TransactionsQuery, TransactionsQueryVariables> & ({
    variables: TransactionsQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): Apollo.QueryResult<TransactionsQuery, Exact<{
    input: TransactionsInput;
}>>;
export declare function useTransactionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TransactionsQuery, TransactionsQueryVariables>): Apollo.LazyQueryResultTuple<TransactionsQuery, Exact<{
    input: TransactionsInput;
}>>;
export declare function useTransactionsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<TransactionsQuery, TransactionsQueryVariables>): Apollo.UseSuspenseQueryResult<TransactionsQuery | undefined, Exact<{
    input: TransactionsInput;
}>>;
export type TransactionsQueryHookResult = ReturnType<typeof useTransactionsQuery>;
export type TransactionsLazyQueryHookResult = ReturnType<typeof useTransactionsLazyQuery>;
export type TransactionsSuspenseQueryHookResult = ReturnType<typeof useTransactionsSuspenseQuery>;
export type TransactionsQueryResult = Apollo.QueryResult<TransactionsQuery, TransactionsQueryVariables>;
export declare function refetchTransactionsQuery(variables: TransactionsQueryVariables): {
    query: Apollo.DocumentNode;
    variables: Exact<{
        input: TransactionsInput;
    }>;
};
export declare const UpdateBillingInfoDocument: Apollo.DocumentNode;
export type UpdateBillingInfoMutationFn = Apollo.MutationFunction<UpdateBillingInfoMutation, UpdateBillingInfoMutationVariables>;
/**
 * __useUpdateBillingInfoMutation__
 *
 * To run a mutation, you first call `useUpdateBillingInfoMutation` within a React component and pass it any options that fit your needs.
 * When your component renders, `useUpdateBillingInfoMutation` returns a tuple that includes:
 * - A mutate function that you can call at any time to execute the mutation
 * - An object with fields that represent the current status of the mutation's execution
 *
 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
 *
 * @example
 * const [updateBillingInfoMutation, { data, loading, error }] = useUpdateBillingInfoMutation({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useUpdateBillingInfoMutation(baseOptions?: Apollo.MutationHookOptions<UpdateBillingInfoMutation, UpdateBillingInfoMutationVariables>): Apollo.MutationTuple<UpdateBillingInfoMutation, Exact<{
    input: UpdateBillingInfoInput;
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
export type UpdateBillingInfoMutationHookResult = ReturnType<typeof useUpdateBillingInfoMutation>;
export type UpdateBillingInfoMutationResult = Apollo.MutationResult<UpdateBillingInfoMutation>;
export type UpdateBillingInfoMutationOptions = Apollo.BaseMutationOptions<UpdateBillingInfoMutation, UpdateBillingInfoMutationVariables>;
export declare const VerifyPolarSessionDocument: Apollo.DocumentNode;
/**
 * __useVerifyPolarSessionQuery__
 *
 * To run a query within a React component, call `useVerifyPolarSessionQuery` and pass it any options that fit your needs.
 * When your component renders, `useVerifyPolarSessionQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useVerifyPolarSessionQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useVerifyPolarSessionQuery(baseOptions: Apollo.QueryHookOptions<VerifyPolarSessionQuery, VerifyPolarSessionQueryVariables> & ({
    variables: VerifyPolarSessionQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): Apollo.QueryResult<VerifyPolarSessionQuery, Exact<{
    input: VerifyPolarSessionInput;
}>>;
export declare function useVerifyPolarSessionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<VerifyPolarSessionQuery, VerifyPolarSessionQueryVariables>): Apollo.LazyQueryResultTuple<VerifyPolarSessionQuery, Exact<{
    input: VerifyPolarSessionInput;
}>>;
export declare function useVerifyPolarSessionSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<VerifyPolarSessionQuery, VerifyPolarSessionQueryVariables>): Apollo.UseSuspenseQueryResult<VerifyPolarSessionQuery | undefined, Exact<{
    input: VerifyPolarSessionInput;
}>>;
export type VerifyPolarSessionQueryHookResult = ReturnType<typeof useVerifyPolarSessionQuery>;
export type VerifyPolarSessionLazyQueryHookResult = ReturnType<typeof useVerifyPolarSessionLazyQuery>;
export type VerifyPolarSessionSuspenseQueryHookResult = ReturnType<typeof useVerifyPolarSessionSuspenseQuery>;
export type VerifyPolarSessionQueryResult = Apollo.QueryResult<VerifyPolarSessionQuery, VerifyPolarSessionQueryVariables>;
export declare function refetchVerifyPolarSessionQuery(variables: VerifyPolarSessionQueryVariables): {
    query: Apollo.DocumentNode;
    variables: Exact<{
        input: VerifyPolarSessionInput;
    }>;
};
export declare const VerifyStripeSessionDocument: Apollo.DocumentNode;
/**
 * __useVerifyStripeSessionQuery__
 *
 * To run a query within a React component, call `useVerifyStripeSessionQuery` and pass it any options that fit your needs.
 * When your component renders, `useVerifyStripeSessionQuery` returns an object from Apollo Client that contains loading, error, and data properties
 * you can use to render your UI.
 *
 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 *
 * @example
 * const { data, loading, error } = useVerifyStripeSessionQuery({
 *   variables: {
 *      input: // value for 'input'
 *   },
 * });
 */
export declare function useVerifyStripeSessionQuery(baseOptions: Apollo.QueryHookOptions<VerifyStripeSessionQuery, VerifyStripeSessionQueryVariables> & ({
    variables: VerifyStripeSessionQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): Apollo.QueryResult<VerifyStripeSessionQuery, Exact<{
    input: VerifyStripeSessionInput;
}>>;
export declare function useVerifyStripeSessionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<VerifyStripeSessionQuery, VerifyStripeSessionQueryVariables>): Apollo.LazyQueryResultTuple<VerifyStripeSessionQuery, Exact<{
    input: VerifyStripeSessionInput;
}>>;
export declare function useVerifyStripeSessionSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<VerifyStripeSessionQuery, VerifyStripeSessionQueryVariables>): Apollo.UseSuspenseQueryResult<VerifyStripeSessionQuery | undefined, Exact<{
    input: VerifyStripeSessionInput;
}>>;
export type VerifyStripeSessionQueryHookResult = ReturnType<typeof useVerifyStripeSessionQuery>;
export type VerifyStripeSessionLazyQueryHookResult = ReturnType<typeof useVerifyStripeSessionLazyQuery>;
export type VerifyStripeSessionSuspenseQueryHookResult = ReturnType<typeof useVerifyStripeSessionSuspenseQuery>;
export type VerifyStripeSessionQueryResult = Apollo.QueryResult<VerifyStripeSessionQuery, VerifyStripeSessionQueryVariables>;
export declare function refetchVerifyStripeSessionQuery(variables: VerifyStripeSessionQueryVariables): {
    query: Apollo.DocumentNode;
    variables: Exact<{
        input: VerifyStripeSessionInput;
    }>;
};
