@bcrumbs.net/inbox 0.0.42 → 0.0.44

package/src/graphql.billing.autogenerated.d.ts

@@ -0,0 +1,1163 @@
+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;
+    /** Renew the current subscription plan. */
+    renew: CheckoutResult;
+    /** Set up a new payment method (creates a setup intent). */
+    setupPaymentMethod: SetupPaymentMethodResult;
+    /** Create or update billing info for a workspace. */
+    updateBillingInfo: BillingInfo;
+};
+export type MutationCancelPendingPaymentArgs = {
+    input: CancelPendingPaymentInput;
+};
+export type MutationCheckoutArgs = {
+    input: CheckoutInput;
+};
+export type MutationRenewArgs = {
+    input: RenewInput;
+};
+export type MutationSetupPaymentMethodArgs = {
+    input: SetupPaymentMethodInput;
+};
+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']>;
+};
+/** 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';
+    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']>;
+    isBroadcastUsed?: Maybe<Scalars['Boolean']['output']>;
+    isConv80PercentUsed?: Maybe<Scalars['Boolean']['output']>;
+    isConv100PercentUsed?: 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'];
+    yearlyPrice: Scalars['Float']['output'];
+};
+/** PlanType represents the type of subscription plan. */
+export declare const PlanType: {
+    readonly BASIC: "basic";
+    readonly CUSTOM: "custom";
+    readonly ENTERPRISE: "enterprise";
+    readonly FREE: "free";
+    readonly PREMIUM: "premium";
+};
+export type PlanType = typeof PlanType[keyof typeof PlanType];
+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 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>;
+};
+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 QuerySubscriptionArgs = {
+    input: SubscriptionInput;
+};
+export type QueryTransactionArgs = {
+    input: TransactionInput;
+};
+export type QueryTransactionsArgs = {
+    input: TransactionsInput;
+};
+/** 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';
+    cardFingerprint?: Maybe<Scalars['String']['output']>;
+    cardId: Scalars['String']['output'];
+    id: Scalars['Int']['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'];
+    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'];
+    term: Term;
+    updatedAt: Scalars['DateTime']['output'];
+    updatingPaymentTries: Scalars['Int']['output'];
+    workspaceId: Scalars['Int']['output'];
+};
+/** 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'];
+};
+/** 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'];
+};
+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;
+            cardId: string;
+            cardFingerprint?: string | 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;
+            cardId: string;
+            cardFingerprint?: string | 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 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 SubscriptionQueryVariables = Exact<{
+    input: SubscriptionInput;
+}>;
+export type SubscriptionQuery = {
+    __typename?: 'Query';
+    subscription: {
+        __typename?: 'SubscriptionPlan';
+        id: number;
+        workspaceId: number;
+        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;
+            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;
+            isBroadcast80PercentUsed?: boolean | null;
+            isBroadcast100PercentUsed?: 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 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 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 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>;