@mft/moneyhub-api-client/dist/index.d.ts

Node.JS client for the Moneyhub API

import { generators } from "openid-client";
import type { ApiClientConfig } from "./schema/config";
declare const _Moneyhub: (apiClientConfig: ApiClientConfig) => Promise<{
    keys: () => {
        keys: import("jose").JWK[];
    } | null;
    generators: typeof generators;
    getConsentHistory: (params?: import("./schema/consent-history").ConsentHistorySearchParams | undefined, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<import("./schema/consent-history").ConsentHistory[]>>;
    categoriseTransactions: import("./requests/types/categorise-transactions").CategoriseTransactionsRequest;
    createResellerCheckRequest: import("./requests/types/reseller-check").CreateResellerCheckRequest;
    registerUser: ({ clientUserId, }: {
        clientUserId?: string | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<Users.User>;
    getUsers: (params?: import("./request").SearchParams | undefined, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Users.User[]>>;
    getSCIMUser: ({ userId }: {
        userId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<any>>;
    registerSCIMUser: (user: import("./schema/scim-user").SCIMUser, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<any>>;
    getUser: ({ userId, }: {
        userId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<Users.User>;
    getUserConnections: ({ userId, }: {
        userId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Connections.UserConnection[]>>;
    deleteUserConnection: ({ userId, connectionId, }: {
        userId: string;
        connectionId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<number>;
    deleteUser: ({ userId, }: {
        userId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<number>;
    getConnectionSyncs: ({ userId, connectionId, params, }: {
        userId: string;
        connectionId: string;
        params?: import("./request").SearchParams | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Syncs.ConnectionSync[]>>;
    getUserSyncs: ({ userId, params, }: {
        userId: string;
        params?: import("./request").SearchParams | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Syncs.ConnectionSync[]>>;
    getSync: ({ userId, syncId, }: {
        userId: string;
        syncId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Syncs.ConnectionSync>>;
    updateUserConnection: ({ userId, connectionId, expiresAt, }: {
        userId: string;
        connectionId: string;
        expiresAt: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<number>;
    getGlobalCounterparties: (params?: Counterparties.GlobalCounterpartiesSearchParams | undefined, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Counterparties.GlobalCounterparty[]>>;
    listConnections: (query?: {
        clientId?: string | undefined;
    } | undefined) => Promise<Connections.WellKnownConnection[]>;
    listAPIConnections: (query?: {
        clientId?: string | undefined;
    } | undefined) => Promise<Connections.WellKnownConnection[]>;
    listTestConnections: (query?: {
        clientId?: string | undefined;
    } | undefined) => Promise<Connections.WellKnownConnection[]>;
    listBetaConnections: (query?: {
        clientId?: string | undefined;
    } | undefined) => Promise<Connections.WellKnownConnection[]>;
    listPaymentsConnections: (query?: {
        clientId?: string | undefined;
    } | undefined) => Promise<Connections.WellKnownConnection[]>;
    getOpenIdConfig: () => Promise<unknown>;
    caasDeleteUser: ({ userId, }: {
        userId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<void>;
    caasPatchTransaction: ({ accountId, transactionId, l2CategoryId, }: {
        accountId: string;
        transactionId: string;
        l2CategoryId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<import("./requests/caas/types/transactions").CaasTransaction[]>>;
    caasEnrichTransactions: ({ transactions, }: {
        transactions: import("./requests/caas/types/transactions").CaasTransactionInput[];
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<import("./requests/caas/types/transactions").CaasTransaction[]>>;
    caasGetTransactions: ({ userId, accountId, limit, }: {
        userId?: string | undefined;
        accountId: string;
        limit?: number | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<import("./requests/caas/types/transactions").CaasTransaction[]>>;
    caasDeleteTransaction: ({ accountId, transactionId, }: {
        accountId: string;
        transactionId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<void>;
    caasGetGeotags: ({ geotagIds, }: {
        geotagIds: string[];
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<import("./requests/caas/types/transactions").CaasGeotag[]>>;
    caasGetCounterparties: ({ limit, offset, }: {
        limit?: number | undefined;
        offset?: number | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<import("./requests/caas/types/transactions").CaasCounterparty[]>>;
    caasGetCategories: (options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<import("./requests/caas/types/categories").CaasCategory[]>>;
    caasGetCategoryGroups: (options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<import("./requests/caas/types/categories").CaasCategoryGroup[]>>;
    caasDeleteAccount: ({ accountId, }: {
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<void>;
    getTransactions: ({ userId, params, }: {
        userId?: string | undefined;
        params?: Transactions.TransactionSearchParams | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Transactions.Transaction[]>>;
    getUnenrichedTransactions: ({ userId, params, }: {
        userId?: string | undefined;
        params?: Transactions.TransactionUnenrichedSearchParams | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Transactions.TransactionUnenriched[]>>;
    getTransaction: ({ userId, transactionId, }: {
        userId?: string | undefined;
        transactionId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Transactions.Transaction>>;
    getUnenrichedTransaction: ({ userId, transactionId, }: {
        userId?: string | undefined;
        transactionId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Transactions.TransactionUnenriched>>;
    addTransaction: ({ userId, transaction, }: {
        userId: string;
        transaction: Transactions.TransactionPost;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Transactions.Transaction>>;
    addTransactions: ({ userId, transactions, params, }: {
        userId: string;
        transactions: Transactions.TransactionPost[];
        params?: {
            categorise?: boolean | undefined;
        } | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<{
        id: string;
    }[]>>;
    updateTransaction: ({ userId, transactionId, transaction, }: {
        userId: string;
        transactionId: string;
        transaction: Partial<Transactions.TransactionPost>;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Transactions.Transaction>>;
    deleteTransaction: ({ userId, transactionId, }: {
        userId: string;
        transactionId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<number>>;
    splitTransaction: ({ userId, transactionId, splits, }: {
        userId: string;
        transactionId: string;
        splits: Transactions.TransactionSplitPost[];
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Transactions.TransactionSplit[]>>;
    getTransactionSplits: ({ userId, transactionId, }: {
        userId?: string | undefined;
        transactionId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Transactions.TransactionSplit[]>>;
    patchTransactionSplit: ({ userId, transactionId, splitId, split, }: {
        userId: string;
        transactionId: string;
        splitId: string;
        split: Transactions.TransactionSplitPatch;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Transactions.TransactionSplit[]>>;
    deleteTransactionSplits: ({ userId, transactionId, }: {
        userId: string;
        transactionId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<number>;
    addFileToTransaction: ({ userId, transactionId, fileData, fileName, }: {
        userId?: string | undefined;
        transactionId: string;
        fileName: string;
        fileData: any;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Transactions.TransactionFile>>;
    getTransactionFiles: ({ userId, transactionId, }: {
        userId?: string | undefined;
        transactionId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Transactions.TransactionFile[]>>;
    getTransactionFile: ({ userId, transactionId, fileId, }: {
        userId?: string | undefined;
        transactionId: string;
        fileId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Transactions.TransactionFile>>;
    deleteTransactionFile: ({ userId, transactionId, fileId, }: {
        userId?: string | undefined;
        transactionId: string;
        fileId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<number>;
    getTaxReturn: ({ userId, params, }: {
        userId?: string | undefined;
        params?: Taxes.TaxSearchParams | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Taxes.Tax>>;
    syncUserConnection: ({ userId, connectionId, customerIpAddress, customerLastLoggedTime, enableAsync, }: {
        userId?: string | undefined;
        connectionId: string;
        customerIpAddress?: string | undefined;
        customerLastLoggedTime?: string | undefined;
        enableAsync?: boolean | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Syncs.SyncResponse>>;
    getStandingOrder: ({ id }: {
        id: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<StandingOrders.StandingOrderRequest>>;
    getStandingOrders: (params?: StandingOrders.StandingOrderSearchParams | undefined, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<StandingOrders.StandingOrderRequest[]>>;
    getSpendingGoals: (params: import("./request").SearchParams, userId: string, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<SpendingGoals.SpendingGoal[]>>;
    getSpendingGoal: ({ goalId, userId, }: {
        goalId: string;
        userId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<SpendingGoals.SpendingGoal>>;
    createSpendingGoal: ({ categoryId, periodType, periodStart, amount, userId, }: {
        categoryId: string;
        periodType?: ("monthly" | "annual") | undefined;
        periodStart?: string | undefined;
        amount: {
            value: number;
        };
        userId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<SpendingGoals.SpendingGoal>>;
    updateSpendingGoal: ({ goalId, categoryId, amount, userId, }: {
        goalId: string;
        categoryId?: string | undefined;
        amount?: {
            value: number;
        } | undefined;
        userId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<SpendingGoals.SpendingGoal>>;
    deleteSpendingGoal: ({ goalId, userId, }: {
        goalId: string;
        userId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<number>;
    getSpendingAnalysis: ({ userId, dates, accountIds, categoryIds, projectIds, }: {
        userId?: string | undefined;
        dates: {
            name: string;
            from: string;
            to: string;
        }[];
        accountIds?: string[] | undefined;
        categoryIds?: string[] | undefined;
        projectIds?: string[] | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<SpendingAnalysis.SpendingAnalysis>>;
    getSavingsGoals: (params: import("./request").SearchParams, userId: string, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<SavingsGoals.SavingsGoal[]>>;
    getSavingsGoal: ({ goalId, userId, }: {
        goalId: string;
        userId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<SavingsGoals.SavingsGoal>>;
    createSavingsGoal: ({ name, imageUrl, notes, accounts, amount, userId, targetDate, }: {
        name: string;
        imageUrl?: string | undefined;
        notes?: string | undefined;
        accounts: {
            id: string;
        }[];
        amount: {
            value: number;
            currency?: string | undefined;
        };
        userId: string;
        targetDate?: string | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<SavingsGoals.SavingsGoal>>;
    updateSavingsGoal: ({ goalId, name, amount, imageUrl, notes, accounts, userId, targetDate, }: {
        goalId: string;
        name?: string | undefined;
        imageUrl?: string | undefined;
        notes?: string | undefined;
        accounts: {
            id: string;
        }[];
        amount?: {
            value: number;
        } | undefined;
        userId: string;
        targetDate?: string | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<SavingsGoals.SavingsGoal>>;
    deleteSavingsGoal: ({ goalId, userId, }: {
        goalId: string;
        userId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<number>;
    getRentalRecords: ({ userId, }: {
        userId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<RentalRecords.RentalRecord[]>>;
    createRentalRecord: ({ userId, rentalData, }: {
        userId: string;
        rentalData: RentalRecords.RentalRecordPost;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<RentalRecords.RentalRecord>>;
    deleteRentalRecord: ({ userId, rentalId, }: {
        userId: string;
        rentalId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<number>;
    getRegularTransactions: ({ userId, params, }: {
        userId?: string | undefined;
        params?: RegularTransactions.RegularTransactionSearchParams | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<RegularTransactions.RegularTransaction[]>>;
    detectRegularTransactions: ({ userId, accountId, }: {
        userId?: string | undefined;
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<RegularTransactions.RegularTransaction[]>>;
    getRecurringPayments: (params?: Payments.RecurringPaymentSearchParams | undefined, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Payments.RecurringPaymentRequest[]>>;
    getRecurringPayment: ({ recurringPaymentId, }: {
        recurringPaymentId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Payments.RecurringPaymentRequest>>;
    makeRecurringPayment: ({ recurringPaymentId, payment, }: {
        recurringPaymentId: string;
        payment: Payments.PaymentsClaims;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Payments.RecurringPaymentRequest>>;
    revokeRecurringPayment: ({ recurringPaymentId, }: {
        recurringPaymentId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<number>;
    confirmFundsForRecurringPayment: ({ recurringPaymentId, fundsConfirmation, }: {
        recurringPaymentId: string;
        fundsConfirmation: Payments.FundsConfirmationRequest;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Payments.FundsConfirmationResponse>>;
    getProjects: ({ userId, params, }: {
        userId: string;
        params?: import("./request").SearchParams | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Projects.Project[]>>;
    getProject: ({ userId, projectId, }: {
        userId: string;
        projectId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Projects.Project>>;
    addProject: ({ userId, project, }: {
        userId: string;
        project: Projects.ProjectPost;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Projects.Project>>;
    updateProject: ({ userId, projectId, project, }: {
        userId: string;
        projectId: string;
        project: Projects.ProjectPatch;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Projects.Project>>;
    deleteProject: ({ userId, projectId, }: {
        userId: string;
        projectId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<number>;
    addPayLink: import("./requests/types/pay-links").AddPayLink;
    getPayLink: import("./requests/types/pay-links").GetPayLink;
    getPayLinks: import("./requests/types/pay-links").GetPayLinks;
    getPayment: ({ id }: {
        id: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Payments.Payment>>;
    getPayments: (params?: Payments.PaymentSearchParams | undefined, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Payments.Payment[]>>;
    getPaymentFromIDToken: ({ idToken }: {
        idToken: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Payments.Payment>>;
    addPayee: ({ accountNumber, sortCode, name, externalId, userId, }: {
        accountNumber: string;
        sortCode: string;
        name: string;
        externalId?: string | undefined;
        userId?: string | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Payees.Payee>>;
    getPayees: (params?: Payees.PayeesSearchParams | undefined, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Payees.Payee[]>>;
    getPayee: ({ id }: {
        id: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Payees.Payee>>;
    getOsipAccounts: ({ userId, params }: {
        userId?: string | undefined;
        params?: import("./request").SearchParams | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<Omit<import("./request").ApiResponse<Osip.OsipAccount[]>, "links">>;
    getOsipAccount: ({ userId, accountId }: {
        userId?: string | undefined;
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<Omit<import("./request").ApiResponse<Osip.OsipAccount>, "links">>;
    getOsipAccountHoldings: ({ userId, accountId, }: {
        userId?: string | undefined;
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Osip.OsipHolding[]>>;
    getOsipAccountTransactions: ({ userId, accountId, }: {
        userId?: string | undefined;
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Osip.OsipTransaction[]>>;
    getNotificationThresholds: ({}: {
        userId?: string | undefined;
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<NotificationThresholds.NotificationThreshold[]>>;
    addNotificationThreshold: ({}: {
        userId?: string | undefined;
        accountId: string;
        threshold: NotificationThresholds.NotificationThresholdBody;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<NotificationThresholds.NotificationThreshold>>;
    updateNotificationThreshold: ({}: {
        userId?: string | undefined;
        accountId: string;
        thresholdId: string;
        threshold: NotificationThresholds.NotificationThresholdBody;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<NotificationThresholds.NotificationThreshold>>;
    deleteNotificationThreshold: ({}: {
        userId?: string | undefined;
        accountId: string;
        thresholdId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<void>;
    getCategories: ({ userId, params, }: {
        userId?: string | undefined;
        params?: (import("./request").SearchParams & {
            type?: Categories.CategoryType | undefined;
        }) | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Categories.Category[]>>;
    getStandardCategories: ({ params, }: {
        params?: (import("./request").SearchParams & {
            type?: Categories.CategoryType | undefined;
        }) | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Categories.Category[]>>;
    getCategory: ({ userId, categoryId, params, }: {
        userId?: string | undefined;
        categoryId: string;
        params?: {
            type?: Categories.CategoryType | undefined;
        } | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Categories.Category>>;
    getCategoryGroups: ({ userId, params, }: {
        userId?: string | undefined;
        params?: {
            type?: Categories.CategoryType | undefined;
        } | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Categories.CategoryGroup[]>>;
    getStandardCategoryGroups: ({ params, }: {
        params?: {
            type?: Categories.CategoryType | undefined;
        } | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Categories.CategoryGroup[]>>;
    createCustomCategory: ({ userId, category, }: {
        userId?: string | undefined;
        category: Categories.CategoryPost;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Categories.Category>>;
    getBeneficiary: ({ id, userId, }: {
        id: string;
        userId?: string | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Beneficiaries.Beneficiary>>;
    getBeneficiaryWithDetail: ({ id, userId, }: {
        id: string;
        userId?: string | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Beneficiaries.BeneficiaryWithDetails>>;
    getBeneficiaries: ({ params, userId, }: {
        params?: import("./request").SearchParams | undefined;
        userId?: string | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Beneficiaries.Beneficiary[]>>;
    getBeneficiariesWithDetail: ({ params, userId, }: {
        params?: import("./request").SearchParams | undefined;
        userId?: string | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Beneficiaries.BeneficiaryWithDetails[]>>;
    createAuthRequest: ({ redirectUri, userId, scope, connectionId, payment, standingOrder, recurringPayment, reversePayment, categorisationType, benefitsCheck, counterpartiesCheck, permissions, permissionsAction, expirationDateTime, transactionsFromDateTime, sync, accountVerification, customerIpAddress, customerLastLoggedTime, accountTypes, accountIdentification, env, }: {
        redirectUri?: string | undefined;
        userId?: string | undefined;
        scope: string;
        connectionId?: string | undefined;
        payment?: Payments.AuthRequestPostPayment | undefined;
        standingOrder?: StandingOrders.AuthRequestStandingOrderPost | undefined;
        recurringPayment?: Payments.AuthRequestPostRecurringPayment | undefined;
        reversePayment?: Payments.AuthRequestPostReversePayment | undefined;
        categorisationType?: Accounts.AccountType | undefined;
        benefitsCheck?: boolean | undefined;
        counterpartiesCheck?: string[] | undefined;
        permissions?: ("ReadStandingOrdersBasic" | "ReadStandingOrdersDetail" | "ReadBeneficiariesDetail" | "ReadAccountsDetail" | "ReadAccountsBasic" | "ReadTransactionsCredits" | "ReadTransactionsDebits" | "ReadTransactionsDetail" | "ReadProducts" | "ReadBalances" | "ReadParty") | undefined;
        permissionsAction?: import("./requests/types/auth-requests").PermissionsAction | undefined;
        expirationDateTime?: string | undefined;
        transactionsFromDateTime?: string | undefined;
        sync?: {
            enableAsync?: boolean | undefined;
        } | undefined;
        accountVerification?: {
            accVerification?: boolean | undefined;
        } | undefined;
        customerIpAddress?: string | undefined;
        customerLastLoggedTime?: string | undefined;
        accountTypes?: string[] | undefined;
        accountIdentification?: string[] | undefined;
        env?: string | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<AuthRequests.AuthRequest>>;
    completeAuthRequest: ({ id, authParams, }: {
        id: string;
        authParams: AuthRequests.AuthParams;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<AuthRequests.AuthRequest>>;
    getAllAuthRequests: (params?: import("./request").SearchParams | undefined, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<AuthRequests.AuthRequest[]>>;
    getAuthRequest: ({ id }: {
        id: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<AuthRequests.AuthRequest>>;
    createAffordability: ({ userId }: {
        userId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Affordability.Affordability>>;
    getAffordability: ({ userId, id }: {
        userId: string;
        id: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Affordability.Affordability>>;
    getAllAffordability: ({ userId, ...query }: {
        userId: string;
    } & import("./request").SearchParams, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Affordability.AffordabilityMetadata[]>>;
    getAccounts: ({ userId, params }: {
        userId?: string | undefined;
        params?: import("./request").SearchParams | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Accounts.Account[]>>;
    getAccountsWithDetails: ({ userId, }: {
        userId?: string | undefined;
        params?: import("./request").SearchParams | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Accounts.AccountWithDetails[]>>;
    getAccountsList: ({ userId, params }: {
        userId?: string | undefined;
        params?: import("./request").SearchParams | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Accounts.Account[]>>;
    getAccountsListWithDetails: ({ userId, }: {
        userId?: string | undefined;
        params?: import("./request").SearchParams | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Accounts.AccountWithDetails[]>>;
    getAccount: ({ userId, accountId }: {
        userId?: string | undefined;
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Accounts.Account>>;
    getAccountBalances: ({ userId, accountId, }: {
        userId?: string | undefined;
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Balances.Balance[]>>;
    getAccountWithDetails: ({ userId, accountId, }: {
        userId?: string | undefined;
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Accounts.AccountWithDetails>>;
    getAccountHoldings: ({ userId, accountId, }: {
        userId?: string | undefined;
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Holdings.HoldingsValuation[]>>;
    getAccountHoldingsWithMatches: ({ userId, accountId, }: {
        userId?: string | undefined;
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Holdings.HoldingWithMatches[]>>;
    getAccountCounterparties: ({ userId, accountId, }: {
        userId?: string | undefined;
        accountId: string;
        params?: import("./request").SearchParams | undefined;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Counterparties.Counterparty[]>>;
    getAccountRecurringTransactions: ({ userId, accountId, }: {
        userId?: string | undefined;
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Transactions.RecurringTransactionEstimate[]>>;
    getAccountStandingOrders: ({ userId, accountId, }: {
        userId?: string | undefined;
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<StandingOrders.StandingOrder[]>>;
    getAccountStandingOrdersWithDetail: ({ userId, accountId, }: {
        userId?: string | undefined;
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<StandingOrders.StandingOrderWithDetail[]>>;
    getAccountStatements: ({ userId, accountId, }: {
        userId?: string | undefined;
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Statements.Statement[]>>;
    getAccountStatementsWithDetail: ({ userId, accountId, }: {
        userId?: string | undefined;
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Statements.Statement[]>>;
    getAccountHolding: ({ userId, accountId, holdingId, }: {
        userId?: string | undefined;
        accountId: string;
        holdingId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Holdings.HoldingWithMatchesAndHistory>>;
    createAccount: ({ userId, account }: {
        userId: string;
        account: Accounts.AccountPost;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Accounts.Account>>;
    deleteAccount: ({ userId, accountId }: {
        userId: string;
        accountId: string;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<number>;
    updateAccount: ({ userId, accountId, account }: {
        userId: string;
        accountId: string;
        account: Accounts.AccountPatch;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Accounts.AccountWithDetails>>;
    addAccountBalance: ({ userId, accountId, balance }: {
        userId: string;
        accountId: string;
        balance: Accounts.AccountBalancePost;
    }, options?: import("./request").ExtraOptions | undefined) => Promise<import("./request").ApiResponse<Accounts.AccountBalancePost>>;
    exchangeCodeForTokensLegacy: ({ state, code, nonce, id_token, }: {
        state: string;
        code: string;
        nonce: string;
        id_token?: string | undefined;
    }) => Promise<import("openid-client").TokenSet>;
    exchangeCodeForTokens: ({ paramsFromCallback, localParams }: {
        paramsFromCallback: import("./exchange-code-for-token").ParamsFromCallback;
        localParams: import("./exchange-code-for-token").LocalParams;
    }) => Promise<import("openid-client").TokenSet>;
    refreshTokens: ({ refreshToken }: {
        refreshToken: string | import("openid-client").TokenSet;
    }) => Promise<import("openid-client").TokenSet>;
    getClientCredentialTokens: ({ scope, sub }: {
        scope: string;
        sub?: string | undefined;
    }) => Promise<import("openid-client").TokenSet>;
    getJWTBearerToken: ({ scope, sub }: {
        scope: string;
        sub: string;
    }) => Promise<import("openid-client").TokenSet>;
    createJWTBearerGrantToken: (subject: string) => Promise<string>;
    getAuthorizeUrl: ({ state, scope, nonce, claims, permissions, permissionsAction, enableAsync, accVerification, expirationDateTime, transactionFromDateTime, codeChallenge, }: {
        state?: string | undefined;
        scope: string;
        nonce?: string | undefined;
        claims?: any;
        permissions?: string[] | undefined;
        permissionsAction?: import("./requests/types/auth-requests").PermissionsAction | undefined;
        enableAsync?: boolean | undefined;
        accVerification?: boolean | undefined;
        expirationDateTime?: string | undefined;
        transactionFromDateTime?: string | undefined;
        codeChallenge?: string | undefined;
    }) => Promise<string>;
    getAuthorizeUrlLegacy: ({ state, scope, nonce, claims, permissions, permissionsAction, enableAsync, expirationDateTime, transactionFromDateTime, codeChallenge, }: {
        state?: string | undefined;
        scope: string;
        nonce?: string | undefined;
        claims?: any;
        permissions?: string[] | undefined;
        permissionsAction?: import("./requests/types/auth-requests").PermissionsAction | undefined;
        enableAsync?: boolean | undefined;
        expirationDateTime?: string | undefined;
        transactionFromDateTime?: string | undefined;
        codeChallenge?: string | undefined;
    }) => Promise<string>;
    getAuthorizeUrlFromRequestUri: ({ requestUri }: {
        requestUri: string;
    }) => string;
    requestObject: ({ scope, state, claims, nonce, pkceParams, }: {
        scope: string;
        state?: string | undefined;
        claims: object;
        nonce?: string | undefined;
        pkceParams?: {
            code_challenge: string;
            code_challenge_method: string;
        } | undefined;
    }) => Promise<string>;
    getRequestUri: (requestObject: any) => Promise<string>;
    getAuthorizeUrlForCreatedUser: ({ bankId, state, nonce, userId, claims, permissions, permissionsAction, expirationDateTime, transactionFromDateTime, enableAsync, codeChallenge, }: {
        bankId: string;
        state?: string | undefined;
        nonce?: string | undefined;
        userId: string;
        claims?: any;
        permissions?: string[] | undefined;
        permissionsAction?: import("./requests/types/auth-requests").PermissionsAction | undefined;
        expirationDateTime?: string | undefined;
        transactionFromDateTime?: string | undefined;
        enableAsync?: boolean | undefined;
        codeChallenge?: string | undefined;
    }) => Promise<string>;
    getReauthAuthorizeUrlForCreatedUser: ({ userId, connectionId, state, nonce, claims, expirationDateTime, transactionFromDateTime, enableAsync, codeChallenge, }: {
        userId: string;
        connectionId: string;
        state?: string | undefined;
        nonce?: string | undefined;
        claims?: any;
        expirationDateTime?: string | undefined;
        transactionFromDateTime?: string | undefined;
        enableAsync?: boolean | undefined;
        codeChallenge: string;
    }) => Promise<string>;
    getReconsentAuthorizeUrlForCreatedUser: ({ userId, connectionId, expiresAt, state, nonce, claims, codeChallenge, }: {
        userId: string;
        connectionId: string;
        state?: string | undefined;
        nonce?: string | undefined;
        claims?: any;
        expiresAt?: string | undefined;
        codeChallenge?: string | undefined;
    }) => Promise<string>;
    getRefreshAuthorizeUrlForCreatedUser: ({ userId, connectionId, state, nonce, claims, expirationDateTime, transactionFromDateTime, enableAsync, codeChallenge, }: {
        userId?: string | undefined;
        connectionId: string;
        state?: string | undefined;
        nonce?: string | undefined;
        claims?: any;
        expirationDateTime?: string | undefined;
        transactionFromDateTime?: string | undefined;
        enableAsync?: boolean | undefined;
        codeChallenge?: string | undefined;
    }) => Promise<string>;
    getPaymentAuthorizeUrl: ({ bankId, payeeRef, payeeId, payee, payer, payeeType, amount, payerRef, payerId, payerType, state, nonce, context, readRefundAccount, userId, claims, codeChallenge, }: {
        bankId: string;
        payeeRef: string;
        payeeId?: string | undefined;
        payeeType?: Payments.PaymentActorType | undefined;
        amount: number;
        payerRef: string;
        payerId?: string | undefined;
        payee?: Payees.RequestPayee | undefined;
        payer?: Payees.RequestPayer | undefined;
        payerType?: Payments.PayerType | undefined;
        state?: string | undefined;
        nonce?: string | undefined;
        context?: string | undefined;
        readRefundAccount?: boolean | undefined;
        userId?: string | undefined;
        claims?: any;
        codeChallenge?: string | undefined;
    }) => Promise<string>;
    getReversePaymentAuthorizeUrl: ({ bankId, paymentId, state, nonce, amount, claims, payerId, payerType, payer, codeChallenge, }: {
        bankId: string;
        paymentId: string;
        state?: string | undefined;
        nonce?: string | undefined;
        amount: number;
        claims?: any;
        payerId?: string | undefined;
        payerType?: Payments.PayerType | undefined;
        payer?: Payees.RequestPayer | undefined;
        codeChallenge?: string | undefined;
    }) => Promise<string>;
    getRecurringPaymentAuthorizeUrl: ({ bankId, payeeId, payee, payeeType, payerId, payerType, reference, validFromDate, validToDate, maximumIndividualAmount, currency, periodicLimits, type, context, state, nonce, userId, claims, codeChallenge, }: {
        bankId: string;
        payeeId?: string | undefined;
        payee?: Payees.RequestPayee | undefined;
        payeeType?: Payments.PaymentActorType | undefined;
        payerId?: string | undefined;
        payerType?: Payments.PayerType | undefined;
        reference?: string | undefined;
        validFromDate?: string | undefined;
        validToDate?: string | undefined;
        maximumIndividualAmount?: number | undefined;
        currency?: string | undefined;
        periodicLimits?: any;
        type?: string | undefined;
        context?: string | undefined;
        state?: string | undefined;
        nonce?: string | undefined;
        userId: string;
        claims?: any;
        codeChallenge?: string | undefined;
    }) => Promise<string>;
    getStandingOrderAuthorizeUrl: ({ bankId, payeeId, payee, payeeType, payerId, payerType, reference, frequency, numberOfPayments, firstPaymentAmount, recurringPaymentAmount, finalPaymentAmount, currency, firstPaymentDate, recurringPaymentDate, finalPaymentDate, state, nonce, context, claims, codeChallenge, }: {
        bankId: string;
        payeeId?: string | undefined;
        payee?: Payees.RequestPayee | undefined;
        payeeType?: Payments.PaymentActorType | undefined;
        payerId?: string | undefined;
        payerType?: Payments.PayerType | undefined;
        reference: string;
        frequency: StandingOrders.StandingOrderFrequency;
        numberOfPayments?: number | undefined;
        firstPaymentAmount: number;
        recurringPaymentAmount: number;
        finalPaymentAmount: number;
        currency?: string | undefined;
        firstPaymentDate: string;
        recurringPaymentDate: string;
        finalPaymentDate: string;
        state?: string | undefined;
        nonce?: string | undefined;
        context: string;
        claims?: any;
        codeChallenge?: string | undefined;
    }) => Promise<string>;
    getPushedAuthorisationRequestUrl: ({ bankId, state, nonce, userId, claims, permissions, permissionsAction, expirationDateTime, transactionFromDateTime, enableAsync, codeChallenge, }: {
        bankId: string;
        state?: string | undefined;
        nonce?: string | undefined;
        userId?: string | undefined;
        context?: string | undefined;
        claims?: any;
        permissions?: string[] | undefined;
        permissionsAction?: import("./requests/types/auth-requests").PermissionsAction | undefined;
        expirationDateTime?: string | undefined;
        transactionFromDateTime?: string | undefined;
        enableAsync?: boolean | undefined;
        codeChallenge?: string | undefined;
    }) => Promise<string>;
}>;
export declare type MoneyhubInstance = Awaited<ReturnType<typeof _Moneyhub>>;
declare const Moneyhub: (apiClientConfig: ApiClientConfig) => Promise<MoneyhubInstance>;
import type * as Accounts from "./schema/account";
import type * as Affordability from "./schema/affordability";
import type * as AuthRequests from "./schema/auth-request";
import type * as Balances from "./schema/balance";
import type * as Beneficiaries from "./schema/beneficiary";
import type * as Categories from "./schema/category";
import type * as CategorisedTransactions from "./schema/categorised-transactions";
import type * as Counterparties from "./schema/counterparty";
import type * as Connections from "./schema/connection";
import type * as Holdings from "./schema/holding";
import type * as NotificationThresholds from "./schema/notification-threshold";
import type * as Osip from "./schema/osip";
import type * as Payees from "./schema/payee";
import type * as Payments from "./schema/payment";
import type * as Projects from "./schema/project";
import type * as RegularTransactions from "./schema/regular-transaction";
import type * as RentalRecords from "./schema/rental-record";
import type * as SavingsGoals from "./schema/savings-goal";
import type * as SpendingAnalysis from "./schema/spending-analysis";
import type * as SpendingGoals from "./schema/spending-goal";
import type * as StandingOrders from "./schema/standing-order";
import type * as Statements from "./schema/statement";
import type * as Syncs from "./schema/sync";
import type * as Taxes from "./schema/tax";
import type * as Transactions from "./schema/transaction";
import type * as Users from "./schema/user";
export { Accounts, Affordability, AuthRequests, Balances, Beneficiaries, Categories, CategorisedTransactions, Counterparties, Connections, Holdings, NotificationThresholds, Osip, Payees, Payments, Projects, RegularTransactions, RentalRecords, SavingsGoals, SpendingAnalysis, SpendingGoals, StandingOrders, Statements, Syncs, Taxes, Transactions, Users, ApiClientConfig, Moneyhub, };
//# sourceMappingURL=index.d.ts.map