@mft/moneyhub-api-client 5.0.0-4 → 5.0.1

package/dist/index.d.ts

@@ -0,0 +1,594 @@
+import { generators } from "openid-client";
+import type { ApiClientConfig } from "./schema/config";
+declare const _Moneyhub: (apiClientConfig: ApiClientConfig) => Promise<{
+    keys: () => {
+        keys: import("./schema/config").JSONWebKey[];
+    } | null;
+    generators: typeof generators;
+    registerUser: ({ clientUserId, }: {
+        clientUserId: string;
+    }) => Promise<Users.User>;
+    getUsers: (params?: import("./request").SearchParams | undefined) => Promise<import("./request").ApiResponse<Users.User[]>>;
+    getSCIMUsers: (params?: import("./request").SearchParams | undefined) => Promise<import("./request").ApiResponse<any>>;
+    getUser: ({ userId, }: {
+        userId: string;
+    }) => Promise<Users.User>;
+    getUserConnections: ({ userId, }: {
+        userId: string;
+    }) => Promise<import("./request").ApiResponse<import("./schema/connection").UserConnection[]>>;
+    deleteUserConnection: ({ userId, connectionId, }: {
+        userId: string;
+        connectionId: string;
+    }) => Promise<number>;
+    deleteUser: ({ userId, }: {
+        userId: string;
+    }) => Promise<number>;
+    getConnectionSyncs: ({ userId, connectionId, params, }: {
+        userId: string;
+        connectionId: string;
+        params?: import("./request").SearchParams | undefined;
+    }) => Promise<import("./request").ApiResponse<Syncs.ConnectionSync[]>>;
+    getSync: ({ userId, syncId, }: {
+        userId: string;
+        syncId: string;
+    }) => Promise<import("./request").ApiResponse<Syncs.ConnectionSync>>;
+    updateUserConnection: ({ userId, connectionId, expiresAt, }: {
+        userId: string;
+        connectionId: string;
+        expiresAt: string;
+    }) => Promise<number>;
+    getGlobalCounterparties: (params?: Counterparties.GlobalCounterpartiesSearchParams | undefined) => Promise<import("./request").ApiResponse<Counterparties.GlobalCounterparty[]>>;
+    listConnections: () => Promise<import("./schema/connection").WellKnownConnection[]>;
+    listAPIConnections: () => Promise<import("./schema/connection").WellKnownConnection[]>;
+    listTestConnections: () => Promise<import("./schema/connection").WellKnownConnection[]>;
+    listBetaConnections: () => Promise<import("./schema/connection").WellKnownConnection[]>;
+    getOpenIdConfig: () => Promise<unknown>;
+    getTransactions: ({ userId, params, }: {
+        userId: string;
+        params?: Transactions.TransactionSearchParams | undefined;
+    }) => Promise<import("./request").ApiResponse<Transactions.Transaction[]>>;
+    getTransaction: ({ userId, transactionId, }: {
+        userId: string;
+        transactionId: string;
+    }) => Promise<import("./request").ApiResponse<Transactions.Transaction>>;
+    addTransaction: ({ userId, transaction, }: {
+        userId: string;
+        transaction: Transactions.TransactionPost;
+    }) => Promise<import("./request").ApiResponse<Transactions.Transaction>>;
+    addTransactions: ({ userId, transactions, params, }: {
+        userId: string;
+        transactions: Transactions.TransactionPost[];
+        params?: {
+            categorise?: boolean | undefined;
+        } | undefined;
+    }) => Promise<import("./request").ApiResponse<{
+        id: string;
+    }[]>>;
+    updateTransaction: ({ userId, transactionId, transaction, }: {
+        userId: string;
+        transactionId: string;
+        transaction: Partial<Transactions.TransactionPost>;
+    }) => Promise<import("./request").ApiResponse<Transactions.Transaction>>;
+    deleteTransaction: ({ userId, transactionId, }: {
+        userId: string;
+        transactionId: string;
+    }) => Promise<import("./request").ApiResponse<number>>;
+    splitTransaction: ({ userId, transactionId, splits, }: {
+        userId: string;
+        transactionId: string;
+        splits: Transactions.TransactionSplitPost[];
+    }) => Promise<import("./request").ApiResponse<Transactions.TransactionSplit[]>>;
+    getTransactionSplits: ({ userId, transactionId, }: {
+        userId: string;
+        transactionId: string;
+    }) => Promise<import("./request").ApiResponse<Transactions.TransactionSplit[]>>;
+    patchTransactionSplit: ({ userId, transactionId, splitId, split, }: {
+        userId: string;
+        transactionId: string;
+        splitId: string;
+        split: Transactions.TransactionSplitPatch;
+    }) => Promise<import("./request").ApiResponse<Transactions.TransactionSplit[]>>;
+    deleteTransactionSplits: ({ userId, transactionId, }: {
+        userId: string;
+        transactionId: string;
+    }) => Promise<number>;
+    addFileToTransaction: ({ userId, transactionId, fileData, fileName, }: {
+        userId: string;
+        transactionId: string;
+        fileName: string;
+        fileData: any;
+    }) => Promise<import("./request").ApiResponse<Transactions.TransactionFile>>;
+    getTransactionFiles: ({ userId, transactionId, }: {
+        userId: string;
+        transactionId: string;
+    }) => Promise<import("./request").ApiResponse<Transactions.TransactionFile[]>>;
+    getTransactionFile: ({ userId, transactionId, fileId, }: {
+        userId: string;
+        transactionId: string;
+        fileId: string;
+    }) => Promise<import("./request").ApiResponse<Transactions.TransactionFile>>;
+    deleteTransactionFile: ({ userId, transactionId, fileId, }: {
+        userId: string;
+        transactionId: string;
+        fileId: string;
+    }) => Promise<number>;
+    getTaxReturn: ({ userId, params, }: {
+        userId: string;
+        params?: Taxes.TaxSearchParams | undefined;
+    }) => Promise<import("./request").ApiResponse<Taxes.Tax>>;
+    syncUserConnection: ({ userId, connectionId, customerIpAddress, customerLastLoggedTime, }: {
+        userId: string;
+        connectionId: string;
+        customerIpAddress?: string | undefined;
+        customerLastLoggedTime?: string | undefined;
+    }) => Promise<import("./request").ApiResponse<Syncs.SyncResponse>>;
+    getStandingOrder: ({ id }: {
+        id: string;
+    }) => Promise<import("./request").ApiResponse<StandingOrders.StandingOrderRequest>>;
+    getStandingOrders: (params?: StandingOrders.StandingOrderSearchParams | undefined) => Promise<import("./request").ApiResponse<StandingOrders.StandingOrderRequest[]>>;
+    getSpendingGoals: (params: import("./request").SearchParams, userId: string) => Promise<import("./request").ApiResponse<SpendingGoals.SpendingGoal[]>>;
+    getSpendingGoal: ({ goalId, userId, }: {
+        goalId: string;
+        userId: string;
+    }) => 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;
+    }) => Promise<import("./request").ApiResponse<SpendingGoals.SpendingGoal>>;
+    updateSpendingGoal: ({ goalId, categoryId, amount, userId, }: {
+        goalId: string;
+        categoryId?: string | undefined;
+        amount?: {
+            value: number;
+        } | undefined;
+        userId: string;
+    }) => Promise<import("./request").ApiResponse<SpendingGoals.SpendingGoal>>;
+    deleteSpendingGoal: ({ goalId, userId, }: {
+        goalId: string;
+        userId: string;
+    }) => Promise<number>;
+    getSpendingAnalysis: ({ userId, dates, accountIds, categoryIds, projectIds, }: {
+        userId: string;
+        dates: {
+            name: string;
+            from: string;
+            to: string;
+        }[];
+        accountIds?: string[] | undefined;
+        categoryIds?: string[] | undefined;
+        projectIds?: string[] | undefined;
+    }) => Promise<import("./request").ApiResponse<SpendingAnalysis.SpendingAnalysis>>;
+    getSavingsGoals: (params: import("./request").SearchParams, userId: string) => Promise<import("./request").ApiResponse<SavingsGoals.SavingsGoal[]>>;
+    getSavingsGoal: ({ goalId, userId, }: {
+        goalId: string;
+        userId: string;
+    }) => Promise<import("./request").ApiResponse<SavingsGoals.SavingsGoal>>;
+    createSavingsGoal: ({ name, imageUrl, notes, accounts, amount, userId, }: {
+        name: string;
+        imageUrl?: string | undefined;
+        notes?: string | undefined;
+        accounts: {
+            id: string;
+        }[];
+        amount: {
+            value: number;
+            currency?: string | undefined;
+        };
+        userId: string;
+    }) => Promise<import("./request").ApiResponse<SavingsGoals.SavingsGoal>>;
+    updateSavingsGoal: ({ goalId, name, amount, imageUrl, notes, accounts, userId, }: {
+        goalId: string;
+        name?: string | undefined;
+        imageUrl?: string | undefined;
+        notes?: string | undefined;
+        accounts: {
+            id: string;
+        }[];
+        amount?: {
+            value: number;
+        } | undefined;
+        userId: string;
+    }) => Promise<import("./request").ApiResponse<SavingsGoals.SavingsGoal>>;
+    deleteSavingsGoal: ({ goalId, userId, }: {
+        goalId: string;
+        userId: string;
+    }) => Promise<number>;
+    getRentalRecords: ({ userId, }: {
+        userId: string;
+    }) => Promise<import("./request").ApiResponse<RentalRecords.RentalRecord[]>>;
+    createRentalRecord: ({ userId, rentalData, }: {
+        userId: string;
+        rentalData: RentalRecords.RentalRecordPost;
+    }) => Promise<import("./request").ApiResponse<RentalRecords.RentalRecord>>;
+    deleteRentalRecord: ({ userId, rentalId, }: {
+        userId: string;
+        rentalId: string;
+    }) => Promise<number>;
+    getRegularTransactions: ({ userId, params, }: {
+        userId: string;
+        params?: RegularTransactions.RegularTransactionSearchParams | undefined;
+    }) => Promise<import("./request").ApiResponse<RegularTransactions.RegularTransaction[]>>;
+    getRecurringPayments: (params?: Payments.RecurringPaymentSearchParams | undefined) => Promise<import("./request").ApiResponse<Payments.RecurringPaymentRequest[]>>;
+    getRecurringPayment: ({ recurringPaymentId, }: {
+        recurringPaymentId: string;
+    }) => Promise<import("./request").ApiResponse<Payments.RecurringPaymentRequest>>;
+    makeRecurringPayment: ({ recurringPaymentId, payment, }: {
+        recurringPaymentId: string;
+        payment: Payments.PaymentsClaims;
+    }) => Promise<import("./request").ApiResponse<Payments.RecurringPaymentRequest>>;
+    revokeRecurringPayment: ({ recurringPaymentId, }: {
+        recurringPaymentId: string;
+    }) => Promise<number>;
+    getProjects: ({ userId, params, }: {
+        userId: string;
+        params?: import("./request").SearchParams | undefined;
+    }) => Promise<import("./request").ApiResponse<Projects.Project[]>>;
+    getProject: ({ userId, projectId, }: {
+        userId: string;
+        projectId: string;
+    }) => Promise<import("./request").ApiResponse<Projects.Project>>;
+    addProject: ({ userId, project, }: {
+        userId: string;
+        project: Projects.ProjectPost;
+    }) => Promise<import("./request").ApiResponse<Projects.Project>>;
+    updateProject: ({ userId, projectId, project, }: {
+        userId: string;
+        projectId: string;
+        project: Projects.ProjectPatch;
+    }) => Promise<import("./request").ApiResponse<Projects.Project>>;
+    deleteProject: ({ userId, projectId, }: {
+        userId: string;
+        projectId: string;
+    }) => Promise<number>;
+    getPayment: ({ id }: {
+        id: string;
+    }) => Promise<import("./request").ApiResponse<Payments.Payment>>;
+    getPayments: (params?: Payments.PaymentSearchParams | undefined) => Promise<import("./request").ApiResponse<Payments.Payment[]>>;
+    getPaymentFromIDToken: ({ idToken }: {
+        idToken: string;
+    }) => Promise<import("./request").ApiResponse<Payments.Payment>>;
+    addPayee: ({ accountNumber, sortCode, name, externalId, userId, }: {
+        accountNumber: string;
+        sortCode: string;
+        name: string;
+        externalId?: string | undefined;
+        userId?: string | undefined;
+    }) => Promise<import("./request").ApiResponse<Payees.Payee>>;
+    getPayees: (params?: Payees.PayeesSearchParams | undefined) => Promise<import("./request").ApiResponse<Payees.Payee[]>>;
+    getPayee: ({ id }: {
+        id: string;
+    }) => Promise<import("./request").ApiResponse<Payees.Payee>>;
+    getCategories: ({ userId, params, }: {
+        userId: string;
+        params?: (import("./request").SearchParams & {
+            type?: Categories.CategoryType | undefined;
+        }) | undefined;
+    }) => Promise<import("./request").ApiResponse<Categories.Category[]>>;
+    getStandardCategories: ({ params, }: {
+        params?: (import("./request").SearchParams & {
+            type?: Categories.CategoryType | undefined;
+        }) | undefined;
+    }) => Promise<import("./request").ApiResponse<Categories.Category[]>>;
+    getCategory: ({ userId, categoryId, params, }: {
+        userId: string;
+        categoryId: string;
+        params?: {
+            type?: Categories.CategoryType | undefined;
+        } | undefined;
+    }) => Promise<import("./request").ApiResponse<Categories.Category>>;
+    getCategoryGroups: ({ userId, params, }: {
+        userId: string;
+        params?: {
+            type?: Categories.CategoryType | undefined;
+        } | undefined;
+    }) => Promise<import("./request").ApiResponse<Categories.CategoryGroup[]>>;
+    getStandardCategoryGroups: ({ params, }: {
+        params?: {
+            type?: Categories.CategoryType | undefined;
+        } | undefined;
+    }) => Promise<import("./request").ApiResponse<Categories.CategoryGroup[]>>;
+    createCustomCategory: ({ userId, category, }: {
+        userId: string;
+        category: Categories.CategoryPost;
+    }) => Promise<import("./request").ApiResponse<Categories.Category>>;
+    getBeneficiary: ({ id, userId, }: {
+        id: string;
+        userId: string;
+    }) => Promise<import("./request").ApiResponse<Beneficiaries.Beneficiary>>;
+    getBeneficiaryWithDetail: ({ id, userId, }: {
+        id: string;
+        userId: string;
+    }) => Promise<import("./request").ApiResponse<Beneficiaries.BeneficiaryWithDetails>>;
+    getBeneficiaries: ({ params, userId, }: {
+        params?: import("./request").SearchParams | undefined;
+        userId: string;
+    }) => Promise<import("./request").ApiResponse<Beneficiaries.Beneficiary[]>>;
+    getBeneficiariesWithDetail: ({ params, userId, }: {
+        params?: import("./request").SearchParams | undefined;
+        userId: string;
+    }) => Promise<import("./request").ApiResponse<Beneficiaries.BeneficiaryWithDetails[]>>;
+    createAuthRequest: ({ redirectUri, userId, scope, connectionId, payment, standingOrder, recurringPayment, reversePayment, categorisationType, benefitsCheck, counterpartiesCheck, permissions, expirationDateTime, transactionsFromDateTime, sync, }: {
+        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") | undefined;
+        expirationDateTime?: string | undefined;
+        transactionsFromDateTime?: string | undefined;
+        sync?: {
+            enableAsync?: boolean | undefined;
+        } | undefined;
+    }) => Promise<import("./request").ApiResponse<AuthRequests.AuthRequest>>;
+    completeAuthRequest: ({ id, authParams, }: {
+        id: string;
+        authParams: AuthRequests.AuthParams;
+    }) => Promise<import("./request").ApiResponse<AuthRequests.AuthRequest>>;
+    getAllAuthRequests: (params?: import("./request").SearchParams | undefined) => Promise<import("./request").ApiResponse<AuthRequests.AuthRequest[]>>;
+    getAuthRequest: ({ id }: {
+        id: string;
+    }) => Promise<import("./request").ApiResponse<AuthRequests.AuthRequest>>;
+    createAffordability: ({ userId }: {
+        userId: string;
+    }) => Promise<import("./request").ApiResponse<Affordability.Affordability>>;
+    getAffordability: ({ userId, id }: {
+        userId: string;
+        id: string;
+    }) => Promise<import("./request").ApiResponse<Affordability.Affordability>>;
+    getAllAffordability: ({ userId, ...query }: {
+        userId: string;
+    } & import("./request").SearchParams) => Promise<import("./request").ApiResponse<Affordability.AffordabilityMetadata[]>>;
+    getAccounts: ({ userId }: {
+        userId: string;
+        params?: import("./request").SearchParams | undefined;
+    }) => Promise<import("./request").ApiResponse<Accounts.Account[]>>;
+    getAccountsWithDetails: ({ userId, }: {
+        userId: string;
+        params?: import("./request").SearchParams | undefined;
+    }) => Promise<Accounts.AccountWithDetails[]>;
+    getAccount: ({ userId, accountId }: {
+        userId: string;
+        accountId: string;
+    }) => Promise<import("./request").ApiResponse<Accounts.Account>>;
+    getAccountBalances: ({ userId, accountId, }: {
+        userId: string;
+        accountId: string;
+    }) => Promise<Balances.Balance[]>;
+    getAccountWithDetails: ({ userId, accountId, }: {
+        userId: string;
+        accountId: string;
+    }) => Promise<import("./request").ApiResponse<Accounts.AccountWithDetails>>;
+    getAccountHoldings: ({ userId, accountId, }: {
+        userId: string;
+        accountId: string;
+    }) => Promise<import("./request").ApiResponse<Holdings.HoldingsValuation[]>>;
+    getAccountHoldingsWithMatches: ({ userId, accountId, }: {
+        userId: string;
+        accountId: string;
+    }) => Promise<import("./request").ApiResponse<Holdings.HoldingWithMatches[]>>;
+    getAccountCounterparties: ({ userId, accountId, }: {
+        userId: string;
+        accountId: string;
+    }) => Promise<import("./request").ApiResponse<Counterparties.Counterparty[]>>;
+    getAccountRecurringTransactions: ({ userId, accountId, }: {
+        userId: string;
+        accountId: string;
+    }) => Promise<import("./request").ApiResponse<Transactions.RecurringTransactionEstimate[]>>;
+    getAccountStandingOrders: ({ userId, accountId, }: {
+        userId: string;
+        accountId: string;
+    }) => Promise<import("./request").ApiResponse<StandingOrders.StandingOrder[]>>;
+    createAccount: ({ userId }: {
+        userId: string;
+        account: Accounts.AccountPost;
+    }) => Promise<import("./request").ApiResponse<Accounts.Account>>;
+    deleteAccount: ({ userId, accountId }: {
+        userId: string;
+        accountId: string;
+    }) => Promise<number>;
+    getAccountHolding: ({ userId, accountId, holdingId, }: {
+        userId: string;
+        accountId: string;
+        holdingId: string;
+    }) => Promise<import("./request").ApiResponse<Holdings.HoldingWithMatchesAndHistory>>;
+    getAccountStandingOrdersWithDetail: ({ userId, accountId, }: {
+        userId: string;
+        accountId: string;
+    }) => Promise<import("./request").ApiResponse<StandingOrders.StandingOrderWithDetail[]>>;
+    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;
+    }) => Promise<import("openid-client").TokenSet>;
+    getJWTBearerToken: ({ scope, sub }: {
+        scope: string;
+        sub: string;
+    }) => Promise<import("openid-client").TokenSet>;
+    createJWTBearerGrantToken: (sub: string) => Promise<string>;
+    getAuthorizeUrl: ({ state, scope, nonce, claims, permissions, enableAsync, expirationDateTime, transactionFromDateTime, }: {
+        state?: string | undefined;
+        scope: string;
+        nonce?: string | undefined;
+        claims?: any;
+        permissions?: string[] | undefined;
+        enableAsync?: boolean | undefined;
+        expirationDateTime?: string | undefined;
+        transactionFromDateTime?: string | undefined;
+    }) => Promise<string>;
+    getAuthorizeUrlFromRequestUri: ({ requestUri }: {
+        requestUri: string;
+    }) => string;
+    requestObject: ({ scope, state, claims, nonce, }: {
+        scope: string;
+        state?: string | undefined;
+        claims: object;
+        nonce?: string | undefined;
+    }) => Promise<string>;
+    getRequestUri: (requestObject: any) => Promise<string>;
+    getAuthorizeUrlForCreatedUser: ({ bankId, state, nonce, userId, claims, permissions, expirationDateTime, transactionFromDateTime, enableAsync, }: {
+        bankId: string;
+        state?: string | undefined;
+        nonce?: string | undefined;
+        userId: string;
+        claims?: any;
+        permissions?: string[] | undefined;
+        expirationDateTime?: string | undefined;
+        transactionFromDateTime?: string | undefined;
+        enableAsync?: boolean | undefined;
+    }) => Promise<string>;
+    getReauthAuthorizeUrlForCreatedUser: ({ userId, connectionId, state, nonce, claims, expirationDateTime, transactionFromDateTime, enableAsync, }: {
+        userId: string;
+        connectionId: string;
+        state?: string | undefined;
+        nonce?: string | undefined;
+        claims?: any;
+        expirationDateTime?: string | undefined;
+        transactionFromDateTime?: string | undefined;
+        enableAsync?: boolean | undefined;
+    }) => Promise<string>;
+    getReconsentAuthorizeUrlForCreatedUser: ({ userId, connectionId, expiresAt, state, nonce, claims, }: {
+        userId: string;
+        connectionId: string;
+        state?: string | undefined;
+        nonce?: string | undefined;
+        claims?: any;
+        expiresAt?: string | undefined;
+    }) => Promise<string>;
+    getRefreshAuthorizeUrlForCreatedUser: ({ userId, connectionId, state, nonce, claims, expirationDateTime, transactionFromDateTime, enableAsync, }: {
+        userId?: string | undefined;
+        connectionId: string;
+        state?: string | undefined;
+        nonce?: string | undefined;
+        claims?: any;
+        expirationDateTime?: string | undefined;
+        transactionFromDateTime?: string | undefined;
+        enableAsync?: boolean | undefined;
+    }) => Promise<string>;
+    getPaymentAuthorizeUrl: ({ bankId, payeeRef, payeeId, payeeType, amount, payerRef, payerId, payerType, state, nonce, context, readRefundAccount, userId, claims, }: {
+        bankId: string;
+        payeeRef: string;
+        payeeId: string;
+        payeeType?: string | undefined;
+        amount: number;
+        payerRef: string;
+        payerId?: string | undefined;
+        payerType?: string | undefined;
+        state?: string | undefined;
+        nonce?: string | undefined;
+        context?: string | undefined;
+        readRefundAccount?: boolean | undefined;
+        userId?: string | undefined;
+        claims?: any;
+    }) => Promise<string>;
+    getReversePaymentAuthorizeUrl: ({ bankId, paymentId, state, nonce, amount, claims, payerId, payerType, }: {
+        bankId: string;
+        paymentId: string;
+        state?: string | undefined;
+        nonce?: string | undefined;
+        amount: number;
+        claims?: any;
+        payerId?: string | undefined;
+        payerType?: Payments.PaymentActorType | undefined;
+    }) => Promise<string>;
+    getRecurringPaymentAuthorizeUrl: ({ bankId, payeeId, payeeType, payerId, payerType, reference, validFromDate, validToDate, maximumIndividualAmount, currency, periodicLimits, type, context, state, nonce, userId, claims, }: {
+        bankId: string;
+        payeeId?: string | undefined;
+        payeeType?: string | undefined;
+        payerId?: string | undefined;
+        payerType?: string | 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;
+    }) => Promise<string>;
+    getStandingOrderAuthorizeUrl: ({ bankId, payeeId, payeeType, payerId, payerType, reference, frequency, numberOfPayments, firstPaymentAmount, recurringPaymentAmount, finalPaymentAmount, currency, firstPaymentDate, recurringPaymentDate, finalPaymentDate, state, nonce, context, claims, }: {
+        bankId: string;
+        payeeId: string;
+        payeeType?: string | undefined;
+        payerId?: string | undefined;
+        payerType?: string | 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;
+    }) => Promise<string>;
+    getPushedAuthorisationRequestUrl: ({ bankId, state, nonce, userId, claims, permissions, expirationDateTime, transactionFromDateTime, enableAsync, codeChallenge, }: {
+        bankId: string;
+        state?: string | undefined;
+        nonce?: string | undefined;
+        userId?: string | undefined;
+        context?: string | undefined;
+        claims?: any;
+        permissions?: string[] | 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 Counterparties from "./schema/counterparty";
+import type * as Holdings from "./schema/holding";
+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 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, Counterparties, Holdings, Payees, Payments, Projects, RegularTransactions, RentalRecords, SavingsGoals, SpendingAnalysis, SpendingGoals, StandingOrders, Syncs, Taxes, Transactions, Users, ApiClientConfig, Moneyhub, };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/{src/index.js → index.js}

@@ -28,14 +28,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Moneyhub = void 0;
 const openid_client_1 = require("openid-client");
-const jose_1 = require("jose");
 const get_auth_urls_1 = __importDefault(require("./get-auth-urls"));
 const tokens_1 = __importDefault(require("./tokens"));
 const requests_1 = __importDefault(require("./requests"));
 const R = __importStar(require("ramda"));
 const request_1 = __importDefault(require("./request"));
 const DEFAULT_TIMEOUT = 60000;
-const Moneyhub = async (apiClientConfig) => {
+const _Moneyhub = async (apiClientConfig) => {
     const config = R.evolve({
         identityServiceUrl: (val) => val.replace("/oidc", ""),
     }, apiClientConfig);
@@ -62,10 +61,11 @@ const Moneyhub = async (apiClientConfig) => {
         ...(0, get_auth_urls_1.default)({ client, config }),
         ...(0, tokens_1.default)({ client, config }),
         ...(0, requests_1.default)({ config, request }),
-        keys: () => (keys && keys.length ? jose_1.JWKS.asKeyStore({ keys }).toJWKS() : null),
+        keys: () => (keys && keys.length ? { keys } : null),
         generators: openid_client_1.generators,
     };
     return moneyhub;
 };
+const Moneyhub = _Moneyhub;
 exports.Moneyhub = Moneyhub;
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iDAAwD;AACxD,oEAAgD;AAChD,sDAAuC;AACvC,0DAAwC;AACxC,yCAA0B;AAC1B,wDAA2B;AAE3B,MAAM,eAAe,GAAG,KAAK,CAAA;AAE7B,MAAM,SAAS,GAAG,KAAK,EAAE,eAAgC,EAAE,EAAE;IAC3D,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CACrB;QACE,kBAAkB,EAAE,CAAC,GAA0C,EAAE,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;KAC7F,EACD,eAAe,CAChB,CAAA;IAED,MAAM,EACJ,kBAAkB,EAClB,OAAO,GAAG,EAAE,EACZ,MAAM,EAAE,EACN,SAAS,EACT,aAAa,EACb,4BAA4B,EAC5B,0BAA0B,EAC1B,YAAY,EACZ,IAAI,EACJ,0BAA0B,GAC3B,GACF,GAAG,MAAM,CAAA;IAEV,MAAM,EAAC,OAAO,GAAG,eAAe,EAAC,GAAG,OAAO,CAAA;IAE3C,sBAAM,CAAC,sBAAsB,CAAC;QAC5B,OAAO;KACR,CAAC,CAAA;IAEF,MAAM,cAAc,GAAG,MAAM,sBAAM,CAAC,QAAQ,CAAC,kBAAkB,GAAG,OAAO,CAAC,CAAA;IAE1E,MAAM,MAAM,GAAG,IAAI,cAAc,CAAC,MAAM,CACtC;QACE,SAAS;QACT,aAAa;QACb,4BAA4B;QAC5B,YAAY;QACZ,0BAA0B;QAC1B,0BAA0B;KAC3B,EACD,EAAC,IAAI,EAAC,CACP,CAAA;IAED,MAAM,CAAC,sBAAM,CAAC,eAAe,CAAC,GAAG,EAAE,CAAA;IAEnC,MAAM,OAAO,GAAG,IAAA,iBAAG,EAAC;QAClB,MAAM;QACN,OAAO,EAAE,EAAC,OAAO,EAAC;KACnB,CAAC,CAAA;IAEF,MAAM,QAAQ,GAAG;QACf,GAAG,IAAA,uBAAkB,EAAC,EAAC,MAAM,EAAE,MAAM,EAAC,CAAC;QACvC,GAAG,IAAA,gBAAgB,EAAC,EAAC,MAAM,EAAE,MAAM,EAAC,CAAC;QACrC,GAAG,IAAA,kBAAe,EAAC,EAAC,MAAM,EAAE,OAAO,EAAC,CAAC;QACrC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAC,IAAI,EAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACjD,UAAU,EAAV,0BAAU;KACX,CAAA;IAED,OAAO,QAAQ,CAAA;AACjB,CAAC,CAAA;AAGD,MAAM,QAAQ,GAAoE,SAAS,CAAA;AA+CzF,4BAAQ"}

package/dist/request.d.ts

@@ -0,0 +1,40 @@
+import { Options } from "got";
+import { Client } from "openid-client";
+import type { ApiClientConfig } from "./schema/config";
+interface RequestOptions extends Pick<Options, "method" | "headers" | "searchParams" | "json" | "form"> {
+    searchParams?: any;
+    body?: Record<string, any>;
+    formData?: any;
+    returnStatus?: boolean;
+    cc?: {
+        scope: string;
+        sub?: string;
+    };
+}
+interface Links {
+    next?: string;
+    prev?: string;
+    self: string;
+}
+export declare type Request = <T>(url: string, opts?: RequestOptions) => Promise<T>;
+export interface RequestsParams {
+    config: ApiClientConfig;
+    request: Request;
+}
+export interface SearchParams {
+    limit?: number;
+    offset?: number;
+}
+export interface ApiResponse<T> {
+    data: T;
+    links?: Links;
+    meta?: object;
+}
+declare const _default: ({ client, options: { timeout }, }: {
+    client: Client;
+    options: {
+        timeout?: number | undefined;
+    };
+}) => <T>(url: string, opts?: RequestOptions) => Promise<T>;
+export default _default;
+//# sourceMappingURL=request.d.ts.map