@justifi/webcomponents 5.6.0 → 5.7.0

package/dist/collection/actions/payment/get-payment-details.js

@@ -1,10 +1,10 @@
 import { Payment } from "../../api";
 import { ComponentErrorSeverity } from "../../api/ComponentError";
 import { getErrorCode, getErrorMessage } from "../../api/services/utils";
-export const makeGetPaymentDetails = ({ id, authToken, service, apiOrigin }) => async ({ onSuccess, onError, final }) => {
+export const makeGetPaymentDetails = ({ id, authToken, service }) => async ({ onSuccess, onError, final }) => {
     var _a;
     try {
-        const response = await service.fetchPayment(id, authToken, apiOrigin);
+        const response = await service.fetchPayment(id, authToken);
         if (!response.error) {
             onSuccess({ payment: new Payment(response.data) });
         }

package/dist/collection/actions/payment/get-payment-transactions.js

@@ -1,10 +1,10 @@
 import { PaymentBalanceTransaction } from "../../api";
 import { ComponentErrorSeverity } from "../../api/ComponentError";
 import { getErrorCode, getErrorMessage } from "../../api/services/utils";
-export const makeGetPaymentTransactions = ({ id, authToken, service, apiOrigin }) => async ({ params, onSuccess, onError, final }) => {
+export const makeGetPaymentTransactions = ({ id, authToken, service }) => async ({ params, onSuccess, onError, final }) => {
     var _a;
     try {
-        const response = await service.fetchPaymentTransactions(id, authToken, params, apiOrigin);
+        const response = await service.fetchPaymentTransactions(id, authToken, params);
         if (!response.error) {
             const balanceTransactions = response.data.map((dataItem) => new PaymentBalanceTransaction(dataItem));
             const pagingInfo = Object.assign({}, response.page_info);

package/dist/collection/actions/payment/get-payments.js

@@ -1,10 +1,10 @@
 import { Payment } from "../../api";
 import { ComponentErrorSeverity } from "../../api/ComponentError";
 import { getErrorCode, getErrorMessage } from "../../api/services/utils";
-export const makeGetPayments = ({ id, authToken, service, apiOrigin }) => async ({ params, onSuccess, onError, final }) => {
+export const makeGetPayments = ({ id, authToken, service }) => async ({ params, onSuccess, onError, final }) => {
     var _a, _b;
     try {
-        const response = await service.fetchPayments(id, authToken, params, apiOrigin);
+        const response = await service.fetchPayments(id, authToken, params);
         if (!response.error) {
             const pagingInfo = Object.assign({}, response.page_info);
             const payments = ((_a = response.data) === null || _a === void 0 ? void 0 : _a.map((dataItem) => new Payment(dataItem))) || [];

package/dist/collection/actions/payout/get-payout-transactions.js

@@ -1,10 +1,10 @@
 import { PayoutBalanceTransaction } from "../../api";
 import { ComponentErrorSeverity } from "../../api/ComponentError";
 import { getErrorCode, getErrorMessage } from "../../api/services/utils";
-export const makeGetPayoutTransactions = ({ authToken, service, apiOrigin }) => async ({ params, onSuccess, onError, final }) => {
+export const makeGetPayoutTransactions = ({ accountId, authToken, service }) => async ({ params, onSuccess, onError, final }) => {
     var _a;
     try {
-        const response = await service.fetchPayoutTransactions(authToken, params, apiOrigin);
+        const response = await service.fetchPayoutTransactions(accountId, authToken, params);
         if (!response.error) {
             const balanceTransactions = response.data.map((dataItem) => new PayoutBalanceTransaction(dataItem));
             const pagingInfo = Object.assign({}, response.page_info);

package/dist/collection/actions/payout/get-payouts.js

@@ -1,10 +1,10 @@
 import { Payout } from "../../api";
 import { ComponentErrorSeverity } from "../../api/ComponentError";
 import { getErrorCode, getErrorMessage } from "../../api/services/utils";
-export const makeGetPayouts = ({ id, authToken, service, apiOrigin }) => async ({ params, onSuccess, onError }) => {
+export const makeGetPayouts = ({ id, authToken, service }) => async ({ params, onSuccess, onError }) => {
     var _a, _b;
     try {
-        const response = await service.fetchPayouts(id, authToken, params, apiOrigin);
+        const response = await service.fetchPayouts(id, authToken, params);
         if (!response.error) {
             const pagingInfo = Object.assign({}, response.page_info);
             const payouts = ((_a = response.data) === null || _a === void 0 ? void 0 : _a.map((dataItem) => new Payout(dataItem))) || [];

package/dist/collection/actions/refund/refund-actions.js

@@ -1,9 +1,9 @@
 import { ComponentErrorSeverity } from "../../api/ComponentError";
 import { getErrorCode, getErrorMessage } from "../../api/services/utils";
-export const makePostRefund = ({ authToken, accountId, paymentId, service, apiOrigin }) => async ({ refundBody, onSuccess, onError, final }) => {
+export const makePostRefund = ({ authToken, accountId, paymentId, service }) => async ({ refundBody, onSuccess, onError, final }) => {
     var _a;
     try {
-        const response = await service.postRefund(paymentId, accountId, authToken, refundBody, apiOrigin);
+        const response = await service.postRefund(paymentId, accountId, authToken, refundBody);
         if (!response.error) {
             onSuccess(response);
         }

package/dist/collection/actions/sub-account/get-subaccounts.js

@@ -1,9 +1,9 @@
 import { ComponentErrorSeverity, SubAccount } from "../../api";
 import { getErrorCode, getErrorMessage } from "../../api/services/utils";
-export const makeGetSubAccounts = ({ accountId, authToken, service, apiOrigin }) => async ({ params, onSuccess, onError }) => {
+export const makeGetSubAccounts = ({ accountId, authToken, service }) => async ({ params, onSuccess, onError }) => {
     var _a, _b;
     try {
-        const response = await service.fetchSubAccounts(accountId, authToken, params, apiOrigin);
+        const response = await service.fetchSubAccounts(accountId, authToken, params);
         if (!response.error) {
             const pagingInfo = Object.assign({}, response.page_info);
             const subAccounts = ((_a = response.data) === null || _a === void 0 ? void 0 : _a.map((dataItem) => new SubAccount(dataItem))) || [];

package/dist/collection/actions/terminal/get-terminal-models.js

@@ -1,9 +1,9 @@
 import { ComponentErrorSeverity, TerminalModel } from "../../api";
 import { getErrorCode, getErrorMessage } from "../../api/services/utils";
-export const makeGetTerminalModels = ({ id, authToken, service, apiOrigin }) => async ({ onSuccess, onError }) => {
+export const makeGetTerminalModels = ({ id, authToken, service }) => async ({ onSuccess, onError }) => {
     var _a, _b, _c, _d;
     try {
-        const response = await service.fetchTerminalModels(id, authToken, apiOrigin);
+        const response = await service.fetchTerminalModels(id, authToken);
         if (!response.error) {
             const terminals = ((_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.terminal_order_models) === null || _b === void 0 ? void 0 : _b.map((dataItem) => new TerminalModel(dataItem))) || [];
             const orderLimit = (_c = response.data) === null || _c === void 0 ? void 0 : _c.order_limit;

package/dist/collection/actions/terminal/get-terminal-orders.js

@@ -1,10 +1,10 @@
 import { TerminalOrder } from "../../api";
 import { ComponentErrorSeverity } from "../../api/ComponentError";
 import { getErrorCode, getErrorMessage } from "../../api/services/utils";
-export const makeGetTerminalOrders = ({ id, authToken, service, apiOrigin }) => async ({ params, onSuccess, onError, final }) => {
+export const makeGetTerminalOrders = ({ id, authToken, service }) => async ({ params, onSuccess, onError, final }) => {
     var _a, _b;
     try {
-        const response = await service.fetchTerminalOrders(id, authToken, params, apiOrigin);
+        const response = await service.fetchTerminalOrders(id, authToken, params);
         if (!response.error) {
             const pagingInfo = Object.assign({}, response.page_info);
             const terminalOrders = ((_a = response.data) === null || _a === void 0 ? void 0 : _a.map((dataItem) => new TerminalOrder(dataItem))) || [];

package/dist/collection/actions/terminal/get-terminals.js

@@ -1,10 +1,10 @@
 import { Terminal } from "../../api";
 import { ComponentErrorSeverity } from "../../api/ComponentError";
 import { getErrorCode, getErrorMessage } from "../../api/services/utils";
-export const makeGetTerminals = ({ id, authToken, service, apiOrigin }) => async ({ params, onSuccess, onError }) => {
+export const makeGetTerminals = ({ id, authToken, service }) => async ({ params, onSuccess, onError }) => {
     var _a, _b;
     try {
-        const response = await service.fetchTerminals(id, authToken, params, apiOrigin);
+        const response = await service.fetchTerminals(id, authToken, params);
         if (!response.error) {
             const pagingInfo = Object.assign({}, response.page_info);
             const terminals = ((_a = response.data) === null || _a === void 0 ? void 0 : _a.map((dataItem) => new Terminal(dataItem))) || [];

package/dist/collection/api/ApiNew.js

@@ -0,0 +1,82 @@
+import { waitForConfig, configState } from "../components/config-provider/config-state";
+import { generateId } from "../utils/utils";
+const Api = () => {
+    async function getAuthorizationHeader(authToken) {
+        if (!authToken) {
+            return {
+                'Content-Type': 'application/json',
+            };
+        }
+        return {
+            Authorization: `Bearer ${authToken}`,
+            'Idempotency-Key': generateId(),
+            'Content-Type': 'application/json',
+        };
+    }
+    async function makeRequest(props) {
+        const { authToken, endpoint, method, params, body, signal, headers } = props;
+        await waitForConfig();
+        const apiOrigin = configState.apiOrigin;
+        const url = `${apiOrigin}/v1/${endpoint}`;
+        const requestUrl = params ? `${url}?${new URLSearchParams(params)}` : url;
+        const defaultHeaders = await getAuthorizationHeader(authToken);
+        const mergedHeaders = Object.assign(Object.assign({}, defaultHeaders), headers);
+        const response = await fetch(requestUrl, {
+            method: method,
+            headers: mergedHeaders,
+            body: body,
+            signal: signal,
+        });
+        if (response) {
+            return response.status === 204 ? {} : response.json();
+        }
+        handleError(requestUrl);
+    }
+    async function get(props) {
+        const { authToken, endpoint, params, signal, headers } = props;
+        return makeRequest({ authToken, endpoint, method: 'GET', params, signal, headers });
+    }
+    async function post(props) {
+        const { authToken, endpoint, body, params, signal, headers } = props;
+        return makeRequest({
+            authToken,
+            endpoint,
+            method: 'POST',
+            params,
+            body: JSON.stringify(body),
+            signal,
+            headers,
+        });
+    }
+    async function put(props) {
+        const { authToken, endpoint, body, params, signal } = props;
+        return makeRequest({
+            authToken,
+            endpoint,
+            method: 'PUT',
+            params,
+            body: JSON.stringify(body),
+            signal,
+        });
+    }
+    async function patch(props) {
+        const { authToken, endpoint, body, params, signal } = props;
+        return makeRequest({
+            authToken,
+            endpoint,
+            method: 'PATCH',
+            params,
+            body: JSON.stringify(body),
+            signal,
+        });
+    }
+    async function destroy(props) {
+        const { authToken, endpoint, params, signal } = props;
+        return makeRequest({ authToken, endpoint, method: 'DELETE', params, signal });
+    }
+    return { get, post, put, patch, destroy };
+};
+function handleError(requestUrl) {
+    console.error(`Error fetching from ${requestUrl}`);
+}
+export default Api;

package/dist/collection/api/services/analytics.service.js

@@ -1,7 +1,8 @@
-import Api from "../Api";
+import Api from "../ApiNew";
+const api = Api();
 export class AnalyticsService {
     async record(body) {
         const endpoint = 'analytics';
-        return Api({ apiOrigin: PROXY_API_ORIGIN }).post({ endpoint, body });
+        return api.post({ endpoint, body });
     }
 }

package/dist/collection/api/services/business.service.js

@@ -1,52 +1,43 @@
-import Api from "../Api";
+import Api from "../ApiNew";
+const api = Api();
 export class BusinessService {
-    async fetchBusiness(businessId, authToken, apiOrigin = PROXY_API_ORIGIN) {
+    async fetchBusiness(businessId, authToken) {
         const endpoint = `entities/business/${businessId}`;
-        return Api({ authToken, apiOrigin }).get({ endpoint });
+        return api.get({ endpoint, authToken });
     }
     async patchBusiness(authToken, businessId, payload) {
         const endpoint = `entities/business/${businessId}`;
-        return Api({ authToken, apiOrigin: PROXY_API_ORIGIN }).patch({
-            endpoint,
-            body: payload,
-        });
+        const body = payload;
+        return api.patch({ endpoint, body, authToken });
     }
 }
 export class IdentityService {
     async fetchIdentity(identityId, authToken) {
         const endpoint = `entities/identity/${identityId}`;
-        return Api({ authToken, apiOrigin: PROXY_API_ORIGIN }).get({ endpoint });
+        return api.get({ endpoint, authToken });
     }
     async patchIdentity(authToken, identityId, payload) {
         const endpoint = `entities/identity/${identityId}`;
-        return Api({ authToken, apiOrigin: PROXY_API_ORIGIN }).patch({
-            endpoint,
-            body: payload,
-        });
+        const body = payload;
+        return api.patch({ endpoint, body, authToken });
     }
     async postIdentity(authToken, payload) {
         const endpoint = `entities/identity`;
-        return Api({ authToken, apiOrigin: PROXY_API_ORIGIN }).post({
-            endpoint,
-            body: payload,
-        });
+        const body = payload;
+        return api.post({ endpoint, body, authToken });
     }
 }
 export class BusinessBankAccountService {
     async postBankAccount(authToken, payload) {
         const endpoint = `entities/bank_accounts`;
-        return Api({ authToken, apiOrigin: PROXY_API_ORIGIN }).post({
-            endpoint,
-            body: payload,
-        });
+        const body = payload;
+        return api.post({ endpoint, body, authToken });
     }
 }
 export class DocumentRecordService {
     async postDocumentRecord(authToken, payload) {
         const endpoint = `entities/document`;
-        return Api({ authToken, apiOrigin: PROXY_API_ORIGIN }).post({
-            endpoint,
-            body: payload,
-        });
+        const body = payload;
+        return api.post({ endpoint, body, authToken });
     }
 }

package/dist/collection/api/services/checkout.service.js

@@ -1,29 +1,23 @@
-import { Api, } from "..";
+import Api from "../ApiNew";
+const api = Api();
 export class CheckoutService {
     async fetchCheckout(authToken, checkoutId) {
         const endpoint = `checkouts/${checkoutId}`;
-        return Api({ authToken, apiOrigin: PROXY_API_ORIGIN }).get({ endpoint });
+        return api.get({ endpoint, authToken });
     }
-    async fetchCheckouts(accountId, authToken, params, apiOrigin) {
-        if (!apiOrigin) {
-            apiOrigin = PROXY_API_ORIGIN;
-        }
-        const headers = { Account: accountId };
-        const api = Api({ authToken, apiOrigin: apiOrigin });
+    async fetchCheckouts(accountId, authToken, params) {
         const endpoint = 'checkouts';
-        return api.get({ endpoint, params, headers });
+        const headers = { Account: accountId };
+        return api.get({ endpoint, params, headers, authToken });
     }
     async complete(authToken, checkoutId, payment) {
         const endpoint = `checkouts/${checkoutId}/complete`;
-        const payload = {
+        const body = {
             payment_mode: payment.payment_mode,
         };
         if (payment.payment_token) {
-            payload.payment_token = payment.payment_token;
+            body.payment_token = payment.payment_token;
         }
-        return Api({ authToken, apiOrigin: PROXY_API_ORIGIN }).post({
-            endpoint,
-            body: payload,
-        });
+        return api.post({ endpoint, body, authToken });
     }
 }

package/dist/collection/api/services/dispute.service.js

@@ -1,28 +1,23 @@
-import { Api } from "..";
+import Api from "../ApiNew";
+const api = Api();
 export class DisputeService {
     async fetchDispute(disputeId, authToken) {
         const endpoint = `disputes/${disputeId}`;
-        return Api({ authToken, apiOrigin: PROXY_API_ORIGIN }).get({ endpoint });
+        return api.get({ endpoint, authToken });
     }
     async updateDisputeResponse(disputeId, authToken, payload) {
         const endpoint = `disputes/${disputeId}/response`;
-        return Api({ authToken, apiOrigin: PROXY_API_ORIGIN }).patch({
-            endpoint,
-            body: payload,
-        });
+        const body = payload;
+        return api.patch({ endpoint, body, authToken });
     }
     async submitDisputeResponse(disputeId, authToken, payload) {
         const endpoint = `disputes/${disputeId}/response`;
-        return Api({ authToken, apiOrigin: PROXY_API_ORIGIN }).post({
-            endpoint,
-            body: payload,
-        });
+        const body = payload;
+        return api.post({ endpoint, body, authToken });
     }
     async createDisputeEvidence(disputeId, authToken, payload) {
         const endpoint = `disputes/${disputeId}/evidence`;
-        return Api({ authToken, apiOrigin: PROXY_API_ORIGIN }).put({
-            endpoint,
-            body: payload,
-        });
+        const body = payload;
+        return api.put({ endpoint, body, authToken });
     }
 }

package/dist/collection/api/services/payment.service.js

@@ -1,16 +1,16 @@
-import { Api } from "..";
+import Api from "../ApiNew";
+const api = Api();
 export class PaymentService {
-    async fetchPayments(accountId, authToken, params, apiOrigin = PROXY_API_ORIGIN) {
-        const api = Api({ authToken, apiOrigin: apiOrigin });
+    async fetchPayments(accountId, authToken, params) {
         const endpoint = `account/${accountId}/payments`;
-        return api.get({ endpoint, params });
+        return api.get({ endpoint, params, authToken });
     }
-    async fetchPayment(paymentId, authToken, apiOrigin = PROXY_API_ORIGIN) {
+    async fetchPayment(paymentId, authToken) {
         const endpoint = `payments/${paymentId}`;
-        return Api({ authToken, apiOrigin }).get({ endpoint });
+        return api.get({ endpoint, authToken });
     }
-    async fetchPaymentTransactions(paymentId, authToken, params, apiOrigin = PROXY_API_ORIGIN) {
+    async fetchPaymentTransactions(paymentId, authToken, params) {
         const endpoint = `payments/${paymentId}/payment_balance_transactions`;
-        return Api({ authToken, apiOrigin }).get({ endpoint, params });
+        return api.get({ endpoint, params, authToken });
     }
 }

package/dist/collection/api/services/payout.service.js

@@ -1,23 +1,21 @@
-import { Api } from "..";
+import Api from "../ApiNew";
+const api = Api();
 export class PayoutService {
-    async fetchPayouts(accountId, authToken, params, apiOrigin = PROXY_API_ORIGIN) {
-        const api = Api({ authToken, apiOrigin });
+    async fetchPayouts(accountId, authToken, params) {
         const endpoint = `account/${accountId}/payouts`;
-        return api.get({ endpoint, params });
+        return api.get({ authToken, endpoint, params });
     }
-    async fetchPayout(payoutId, authToken, apiOrigin = PROXY_API_ORIGIN) {
-        const api = Api({ authToken, apiOrigin });
+    async fetchPayout(payoutId, authToken) {
         const endpoint = `payouts/${payoutId}`;
-        return api.get({ endpoint });
+        return api.get({ authToken, endpoint });
     }
-    async fetchCSV(payoutId, authToken, apiOrigin = PROXY_API_ORIGIN) {
-        const api = Api({ authToken, apiOrigin });
+    async fetchCSV(payoutId, authToken) {
         const endpoint = `reports/payouts/${payoutId}`;
-        return api.get({ endpoint });
+        return api.get({ authToken, endpoint });
     }
-    async fetchPayoutTransactions(authToken, params, apiOrigin = PROXY_API_ORIGIN) {
-        const api = Api({ authToken, apiOrigin });
+    async fetchPayoutTransactions(accountId, authToken, params) {
         const endpoint = `balance_transactions`;
-        return api.get({ endpoint, params });
+        const headers = { 'sub-account': accountId };
+        return api.get({ authToken, endpoint, params, headers });
     }
 }

package/dist/collection/api/services/provision.service.js

@@ -1,14 +1,12 @@
-import Api from "../Api";
+import Api from "../ApiNew";
+const api = Api();
 export class ProvisionService {
     async postProvisioning(authToken, businessId, product) {
         const endpoint = `entities/provisioning`;
-        const payload = {
+        const body = {
             business_id: businessId,
             product_category: product,
         };
-        return Api({ authToken, apiOrigin: PROXY_API_ORIGIN }).post({
-            endpoint,
-            body: payload,
-        });
+        return api.post({ endpoint, body, authToken });
     }
 }

package/dist/collection/api/services/refund.service.js

@@ -1,10 +1,11 @@
-import { Api } from "..";
+import Api from "../ApiNew";
+const api = Api();
 ;
 export class RefundService {
-    async postRefund(paymentId, accountId, authToken, refundBody, apiOrigin = PROXY_API_ORIGIN) {
-        const api = Api({ authToken, apiOrigin });
+    async postRefund(paymentId, accountId, authToken, refundBody) {
         const endpoint = `payments/${paymentId}/refunds`;
         const headers = { 'Sub-Account': accountId };
-        return api.post({ endpoint, headers, body: refundBody });
+        const body = refundBody;
+        return api.post({ endpoint, headers, body, authToken });
     }
 }

package/dist/collection/api/services/subaccounts.service.js

@@ -1,9 +1,9 @@
-import { Api } from "..";
+import Api from "../ApiNew";
+const api = Api();
 export class SubAccountService {
-    async fetchSubAccounts(accountId, authToken, params, apiOrigin = PROXY_API_ORIGIN) {
-        const headers = { Account: accountId };
-        const api = Api({ authToken, apiOrigin: apiOrigin });
+    async fetchSubAccounts(accountId, authToken, params) {
         const endpoint = 'sub_accounts';
-        return api.get({ endpoint, params, headers });
+        const headers = { Account: accountId };
+        return api.get({ authToken, endpoint, params, headers });
     }
 }

package/dist/collection/api/services/terminal.service.js

@@ -1,25 +1,24 @@
-import { Api } from "..";
+import Api from "../ApiNew";
+const api = Api();
 export class TerminalService {
-    async fetchTerminals(accountId, authToken, params, apiOrigin = PROXY_API_ORIGIN) {
-        const headers = { Account: accountId };
-        const api = Api({ authToken, apiOrigin });
+    async fetchTerminals(accountId, authToken, params) {
         const endpoint = 'terminals';
-        return api.get({ endpoint, params, headers });
+        const headers = { Account: accountId };
+        return api.get({ endpoint, params, headers, authToken });
     }
-    async fetchTerminal(terminalId, authToken, apiOrigin = PROXY_API_ORIGIN) {
+    async fetchTerminal(terminalId, authToken) {
         const endpoint = `terminals/${terminalId}`;
-        return Api({ authToken, apiOrigin: apiOrigin }).get({ endpoint });
+        return api.get({ endpoint, authToken });
     }
-    async fetchTerminalModels(accountId, authToken, apiOrigin = API_ORIGIN) {
-        const headers = { 'sub-account': accountId };
-        const api = Api({ authToken, apiOrigin });
+    async fetchTerminalModels(accountId, authToken) {
         const endpoint = 'terminals/order_models';
-        return api.get({ endpoint, headers });
+        const headers = { 'sub-account': accountId };
+        return api.get({ endpoint, headers, authToken });
     }
-    async orderTerminals(authToken, terminalOrder, apiOrigin = API_ORIGIN) {
-        const headers = { 'sub-account': terminalOrder.sub_account_id };
-        const api = Api({ authToken, apiOrigin });
+    async orderTerminals(authToken, terminalOrder) {
         const endpoint = 'terminals/orders';
-        return api.post({ endpoint, body: terminalOrder, headers });
+        const body = terminalOrder;
+        const headers = { 'sub-account': terminalOrder.sub_account_id };
+        return api.post({ endpoint, body, headers, authToken });
     }
 }

package/dist/collection/api/services/terminal_orders.service.js

@@ -1,13 +1,9 @@
-import { Api } from "..";
+import Api from "../ApiNew";
+const api = Api();
 export class TerminalOrderService {
-    async fetchTerminalOrders(accountId, authToken, params, apiOrigin = PROXY_API_ORIGIN) {
-        const headers = { account: accountId };
-        const api = Api({ authToken, apiOrigin });
+    async fetchTerminalOrders(accountId, authToken, params) {
         const endpoint = 'terminals/orders';
-        return api.get({
-            endpoint,
-            params,
-            headers,
-        });
+        const headers = { account: accountId };
+        return api.get({ endpoint, params, headers, authToken });
     }
 }

package/dist/collection/collection-manifest.json

@@ -53,8 +53,9 @@
     "components/checkouts-list/checkouts-list-core.js",
     "components/checkouts-list/checkouts-list-filters.js",
     "components/checkouts-list/checkouts-list.js",
-    "ui-components/filters/table-filters-menu.js",
+    "components/filters/table-filters-menu.js",
     "ui-components/form/form-control-select.js",
+    "components/config-provider/config-provider.js",
     "components/dispute-management/dispute-management-core.js",
     "components/dispute-management/dispute-management.js",
     "components/dispute-management/dispute-notification.js",
@@ -113,7 +114,7 @@
   ],
   "compiler": {
     "name": "@stencil/core",
-    "version": "4.30.0",
+    "version": "4.31.0",
     "typescriptVersion": "5.5.4"
   },
   "collections": [],