@djust-b2b/djust-front-sdk 3.0.0-beta.4 → 3.0.0-beta.6

package/dist/index.cjs

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * DJUST SDK
+ *
+ * This module exports both the legacy singleton API (DjustSDK) and
+ * the new SSR-safe client factory (createDjustClient).
+ *
+ * ## For Browser / SPA usage (legacy, still supported):
+ * ```typescript
+ * import { DjustSDK } from '@djust-b2b/djust-front-sdk';
+ * DjustSDK.initialize({ baseUrl, clientId, apiKey });
+ * const cart = await DjustSDK.getCart({ cartId, currency });
+ * ```
+ *
+ * ## For SSR / Nuxt / BFF usage (recommended):
+ * ```typescript
+ * import { createDjustClient } from '@djust-b2b/djust-front-sdk';
+ *
+ * const client = createDjustClient({ baseUrl, clientId, apiKey });
+ * const sdk = client.withContext({ accessToken, customerAccountId });
+ * const cart = await sdk.getCart({ cartId, currency });
+ * ```
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHttpStatus = exports.isApiError = exports.withStructuredErrors = exports.withLegacyErrors = exports.parseLegacyError = exports.isLegacyError = exports.fromLegacyError = exports.toLegacyError = exports.getUserFriendlyMessage = exports.extractErrorCode = exports.extractStatusCode = exports.isTransientError = exports.isClientError = exports.shouldReauthenticate = exports.getRetryDelay = exports.isRetryable = exports.isUnexpectedError = exports.isRateLimitError = exports.isNotFoundError = exports.isValidationError = exports.isServerError = exports.isTimeoutError = exports.isNetworkError = exports.isForbiddenError = exports.isAuthError = exports.isSDKError = exports.createErrorFromException = exports.createErrorFromResponse = exports.UnexpectedError = exports.ServerError = exports.TimeoutError = exports.NetworkError = exports.RateLimitError = exports.NotFoundError = exports.ForbiddenError = exports.AuthError = exports.ValidationError = exports.RETRIABLE_HTTP_STATUS_CODES = exports.RETRIABLE_ERROR_CODES = exports.SDKErrorCode = exports.SDKError = exports.createDjustClient = exports.DjustSDK = void 0;
+const tslib_1 = require("tslib");
+const AuthServices = tslib_1.__importStar(require("./services/auth"));
+const CartServices = tslib_1.__importStar(require("./services/cart"));
+const CustomerAccountServices = tslib_1.__importStar(require("./services/customer-account"));
+const CustomerUserServices = tslib_1.__importStar(require("./services/customer-user"));
+const NavigationCategoryServices = tslib_1.__importStar(require("./services/navigation-category"));
+const ProductServices = tslib_1.__importStar(require("./services/product"));
+const ProductVariantServices = tslib_1.__importStar(require("./services/product-variant"));
+const QuoteServices = tslib_1.__importStar(require("./services/quote"));
+const SupplierServices = tslib_1.__importStar(require("./services/supplier"));
+const CommercialOrderServices = tslib_1.__importStar(require("./services/commercial-order"));
+const LogisticOrderServices = tslib_1.__importStar(require("./services/logistic-order"));
+const IncidentServices = tslib_1.__importStar(require("./services/incident"));
+const OfferServices = tslib_1.__importStar(require("./services/offer-inventories"));
+const CustomFieldServices = tslib_1.__importStar(require("./services/custom-field"));
+const PaymentServices = tslib_1.__importStar(require("./services/payment"));
+const OperationServices = tslib_1.__importStar(require("./services/operation"));
+const fetch_instance_1 = require("./settings/fetch-instance");
+// ============================================================================
+// LEGACY API (Backward Compatible)
+// ============================================================================
+/**
+ * Legacy singleton SDK.
+ *
+ * @deprecated For SSR/BFF usage, prefer `createDjustClient()` which provides
+ * isolated state per request. The singleton API is kept for backward
+ * compatibility but may cause race conditions in SSR environments.
+ *
+ * @example
+ * ```typescript
+ * // Browser usage (still works)
+ * DjustSDK.initialize({ baseUrl, clientId, apiKey });
+ * DjustSDK.updateConfiguration({ accessToken: token });
+ * const cart = await DjustSDK.getCart({ cartId, currency });
+ * ```
+ */
+exports.DjustSDK = {
+    ...AuthServices,
+    ...CartServices,
+    ...CustomerAccountServices,
+    ...CustomerUserServices,
+    ...NavigationCategoryServices,
+    ...ProductServices,
+    ...ProductVariantServices,
+    ...QuoteServices,
+    ...SupplierServices,
+    ...LogisticOrderServices,
+    ...CommercialOrderServices,
+    ...IncidentServices,
+    ...OfferServices,
+    ...CustomFieldServices,
+    ...PaymentServices,
+    ...OperationServices,
+    /**
+     * @deprecated Use `createDjustClient()` for SSR-safe usage.
+     */
+    initialize: fetch_instance_1.initialize,
+    /**
+     * @deprecated Use `client.withContext()` for SSR-safe per-request configuration.
+     */
+    updateConfiguration: fetch_instance_1.updateConfiguration,
+};
+// ============================================================================
+// NEW SSR-SAFE API (v2.17.0+)
+// ============================================================================
+/**
+ * Creates a new DJUST SDK client with isolated state.
+ *
+ * This is the recommended API for SSR environments (Nuxt, Nitro, Next.js).
+ * Each call to `withContext()` returns an isolated client that does not
+ * share state with other requests.
+ *
+ * @example
+ * ```typescript
+ * // Create client once at app initialization
+ * const djust = createDjustClient({
+ *   baseUrl: 'https://api.djust.io',
+ *   clientId: 'your-client-id',
+ *   apiKey: 'your-api-key',
+ *   timeout: 30000,
+ *   strictErrors: true,
+ * });
+ *
+ * // In SSR request handler
+ * export default defineEventHandler(async (event) => {
+ *   const sdk = djust.withContext({
+ *     accessToken: getCookie(event, 'token'),
+ *     customerAccountId: getCookie(event, 'customer-account-id'),
+ *     requestId: getRequestHeader(event, 'x-request-id'),
+ *   });
+ *
+ *   return await sdk.getCart({ cartId: '123', currency: 'EUR' });
+ * });
+ * ```
+ *
+ * @since 2.17.0
+ */
+var client_1 = require("./client");
+Object.defineProperty(exports, "createDjustClient", { enumerable: true, get: function () { return client_1.createDjustClient; } });
+// ============================================================================
+// ERROR TYPES (v2.17.0+)
+// ============================================================================
+var errors_1 = require("./errors");
+// Base error & codes
+Object.defineProperty(exports, "SDKError", { enumerable: true, get: function () { return errors_1.SDKError; } });
+Object.defineProperty(exports, "SDKErrorCode", { enumerable: true, get: function () { return errors_1.SDKErrorCode; } });
+Object.defineProperty(exports, "RETRIABLE_ERROR_CODES", { enumerable: true, get: function () { return errors_1.RETRIABLE_ERROR_CODES; } });
+Object.defineProperty(exports, "RETRIABLE_HTTP_STATUS_CODES", { enumerable: true, get: function () { return errors_1.RETRIABLE_HTTP_STATUS_CODES; } });
+// Error subclasses
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_1.ValidationError; } });
+Object.defineProperty(exports, "AuthError", { enumerable: true, get: function () { return errors_1.AuthError; } });
+Object.defineProperty(exports, "ForbiddenError", { enumerable: true, get: function () { return errors_1.ForbiddenError; } });
+Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return errors_1.NotFoundError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_1.RateLimitError; } });
+Object.defineProperty(exports, "NetworkError", { enumerable: true, get: function () { return errors_1.NetworkError; } });
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_1.TimeoutError; } });
+Object.defineProperty(exports, "ServerError", { enumerable: true, get: function () { return errors_1.ServerError; } });
+Object.defineProperty(exports, "UnexpectedError", { enumerable: true, get: function () { return errors_1.UnexpectedError; } });
+// Factory functions
+Object.defineProperty(exports, "createErrorFromResponse", { enumerable: true, get: function () { return errors_1.createErrorFromResponse; } });
+Object.defineProperty(exports, "createErrorFromException", { enumerable: true, get: function () { return errors_1.createErrorFromException; } });
+// Type guards
+Object.defineProperty(exports, "isSDKError", { enumerable: true, get: function () { return errors_1.isSDKError; } });
+Object.defineProperty(exports, "isAuthError", { enumerable: true, get: function () { return errors_1.isAuthError; } });
+Object.defineProperty(exports, "isForbiddenError", { enumerable: true, get: function () { return errors_1.isForbiddenError; } });
+Object.defineProperty(exports, "isNetworkError", { enumerable: true, get: function () { return errors_1.isNetworkError; } });
+Object.defineProperty(exports, "isTimeoutError", { enumerable: true, get: function () { return errors_1.isTimeoutError; } });
+Object.defineProperty(exports, "isServerError", { enumerable: true, get: function () { return errors_1.isServerError; } });
+Object.defineProperty(exports, "isValidationError", { enumerable: true, get: function () { return errors_1.isValidationError; } });
+Object.defineProperty(exports, "isNotFoundError", { enumerable: true, get: function () { return errors_1.isNotFoundError; } });
+Object.defineProperty(exports, "isRateLimitError", { enumerable: true, get: function () { return errors_1.isRateLimitError; } });
+Object.defineProperty(exports, "isUnexpectedError", { enumerable: true, get: function () { return errors_1.isUnexpectedError; } });
+// Utility functions
+Object.defineProperty(exports, "isRetryable", { enumerable: true, get: function () { return errors_1.isRetryable; } });
+Object.defineProperty(exports, "getRetryDelay", { enumerable: true, get: function () { return errors_1.getRetryDelay; } });
+Object.defineProperty(exports, "shouldReauthenticate", { enumerable: true, get: function () { return errors_1.shouldReauthenticate; } });
+Object.defineProperty(exports, "isClientError", { enumerable: true, get: function () { return errors_1.isClientError; } });
+Object.defineProperty(exports, "isTransientError", { enumerable: true, get: function () { return errors_1.isTransientError; } });
+Object.defineProperty(exports, "extractStatusCode", { enumerable: true, get: function () { return errors_1.extractStatusCode; } });
+Object.defineProperty(exports, "extractErrorCode", { enumerable: true, get: function () { return errors_1.extractErrorCode; } });
+Object.defineProperty(exports, "getUserFriendlyMessage", { enumerable: true, get: function () { return errors_1.getUserFriendlyMessage; } });
+// Backward compatibility helpers
+Object.defineProperty(exports, "toLegacyError", { enumerable: true, get: function () { return errors_1.toLegacyError; } });
+Object.defineProperty(exports, "fromLegacyError", { enumerable: true, get: function () { return errors_1.fromLegacyError; } });
+Object.defineProperty(exports, "isLegacyError", { enumerable: true, get: function () { return errors_1.isLegacyError; } });
+Object.defineProperty(exports, "parseLegacyError", { enumerable: true, get: function () { return errors_1.parseLegacyError; } });
+Object.defineProperty(exports, "withLegacyErrors", { enumerable: true, get: function () { return errors_1.withLegacyErrors; } });
+Object.defineProperty(exports, "withStructuredErrors", { enumerable: true, get: function () { return errors_1.withStructuredErrors; } });
+Object.defineProperty(exports, "isApiError", { enumerable: true, get: function () { return errors_1.isApiError; } });
+Object.defineProperty(exports, "getHttpStatus", { enumerable: true, get: function () { return errors_1.getHttpStatus; } });
+// ============================================================================
+// INTERFACES (unchanged)
+// ============================================================================
+tslib_1.__exportStar(require("./interfaces"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -0,0 +1,265 @@
+/**
+ * DJUST SDK
+ *
+ * This module exports both the legacy singleton API (DjustSDK) and
+ * the new SSR-safe client factory (createDjustClient).
+ *
+ * ## For Browser / SPA usage (legacy, still supported):
+ * ```typescript
+ * import { DjustSDK } from '@djust-b2b/djust-front-sdk';
+ * DjustSDK.initialize({ baseUrl, clientId, apiKey });
+ * const cart = await DjustSDK.getCart({ cartId, currency });
+ * ```
+ *
+ * ## For SSR / Nuxt / BFF usage (recommended):
+ * ```typescript
+ * import { createDjustClient } from '@djust-b2b/djust-front-sdk';
+ *
+ * const client = createDjustClient({ baseUrl, clientId, apiKey });
+ * const sdk = client.withContext({ accessToken, customerAccountId });
+ * const cart = await sdk.getCart({ cartId, currency });
+ * ```
+ *
+ * @packageDocumentation
+ */
+/**
+ * Legacy singleton SDK.
+ *
+ * @deprecated For SSR/BFF usage, prefer `createDjustClient()` which provides
+ * isolated state per request. The singleton API is kept for backward
+ * compatibility but may cause race conditions in SSR environments.
+ *
+ * @example
+ * ```typescript
+ * // Browser usage (still works)
+ * DjustSDK.initialize({ baseUrl, clientId, apiKey });
+ * DjustSDK.updateConfiguration({ accessToken: token });
+ * const cart = await DjustSDK.getCart({ cartId, currency });
+ * ```
+ */
+export declare const DjustSDK: {
+    /**
+     * @deprecated Use `createDjustClient()` for SSR-safe usage.
+     */
+    initialize: (initConfig: import("./settings/fetch-instance").ClientConfig) => void;
+    /**
+     * @deprecated Use `client.withContext()` for SSR-safe per-request configuration.
+     */
+    updateConfiguration: (newConfig: Partial<import("./settings/fetch-instance").ClientConfig>) => void;
+    getShopOperations({ page, size, sort, ids, name, startDateFrom, startDateTo, endDateFrom, endDateTo, locale, }: import("./services/operation/definitions").GetShopOperationsParameters): Promise<import("./services/operation/definitions").GetShopOperationsResponse>;
+    getOperations({ page, size, sort, type, status, ids, name, startDateFrom, startDateTo, endDateFrom, endDateTo, ownerIds, idType, locale, }: import("./services/operation/definitions").GetOperationsParameters): Promise<import("./services/operation/definitions").GetOperationsResponse>;
+    getShopOperation({ operationId, locale, }: import("./services/operation/definitions").GetShopOperationParameters): Promise<import("./services/operation/definitions").GetShopOperationResponse>;
+    getOperation({ operationId, }: import("./services/operation/definitions").GetOperationParameters): Promise<import("./services/operation/definitions").GetOperationResponse>;
+    updateOperation({ operationId, status, }: import("./services/operation/definitions").UpdateOperationParameters): Promise<void>;
+    updateOperationDetails({ operationId, customFieldValues, descriptions, endDate, names, startDate, }: import("./services/operation/definitions").UpdateOperationDetailsParameters): Promise<import("./services/operation/definitions").UpdateOperationDetailsResponse>;
+    removeOperationAccounts({ operationId, accountIds, }: import("./services/operation/definitions").RemoveOperationAccountsParameters): Promise<void>;
+    getOperationAccounts({ operationId, page, size, sort, accountIds, accountName, }: import("./services/operation/definitions").GetOperationAccountsParameters): Promise<import("./services/operation/definitions").GetOperationAccountsResponse>;
+    addOperationAccounts({ operationId, accountIds, }: import("./services/operation/definitions").AddOperationAccountsParameters): Promise<void>;
+    removeOperationLines({ operationId, variantIds, }: import("./services/operation/definitions").RemoveOperationLinesParameters): Promise<void>;
+    getShopOperationLines({ operationId, page, size, sort, variantIds, variantName, locale, }: import("./services/operation/definitions").GetShopOperationLinesParameters): Promise<import("./services/operation/definitions").GetShopOperationLinesResponse>;
+    getOperationLines({ operationId, page, size, sort, variantIds, variantName, minQuantity, maxQuantity, recommendedQuantity, locale, }: import("./services/operation/definitions").GetOperationLinesParameters): Promise<import("./services/operation/definitions").GetOperationLinesResponse>;
+    addOperationLines({ operationId, lines, }: import("./services/operation/definitions").AddOperationLinesParameters): Promise<void>;
+    createOperation({ customFieldValues, descriptions, endDate, externalId, names, startDate, type, }: import("./services/operation/definitions").CreateOperationParameters): Promise<import("./services/operation/definitions").CreateOperationResponse>;
+    deleteOperation({ operationId, }: import("./services/operation/definitions").DeleteOperationParameters): Promise<void>;
+    initPayment({ browserInfo, countryCode, customerUserIP, paymentMethodData, reference, referenceType, returnPath, storePaymentMethod, }: import("./services/payment/definitions").InitPaymentRequest): Promise<import("./services/payment/definitions").InitPaymentResponse>;
+    getPaymentDetails({ details, }: import("./services/payment/definitions").GetPaymentDetailsRequest): Promise<import("./services/payment/definitions").GetPaymentDetailsResponse>;
+    getPaymentMethods({ reference, countryCode, referenceType, locale, }: import("./services/payment/definitions").GetPaymentMethodsRequest): Promise<import("./services/payment/definitions").GetPaymentMethodsResponse>;
+    deleteStoredPaymentMethodById({ storedPaymentMethodId, }: import("./services/payment/definitions").DeleteStoredPaymentMethodByIdRequest): Promise<void>;
+    precheckPurchaseCardL3({ reference, referenceType, }: import("./services/payment/definitions").PrecheckPurchaseCardL3Request): Promise<import("./services/payment/definitions").PrecheckPurchaseCardL3Response>;
+    getCustomFields(params: import("./services/custom-field/definitions").GetCustomFieldParameters): Promise<import("./services/custom-field/definitions").GetCustomFieldResponse>;
+    postMediaCustomField(params: import("./services/custom-field/definitions").PostMediaCustomFieldParameters): Promise<string>;
+    getMediaUrl(params: import("./services/custom-field/definitions").GetMediaUrlParameters): Promise<string>;
+    getPaginatedOfferInventories({ page, size, sort, productStatus, offerInventoryStatus, variantStatus, offerPriceStatus, supplierId, offersIds, offerPriceIds, currency, hasStock, idType, }: import("./services/offer-inventories/definitions").GetPaginatedOfferInventoriesParameters): Promise<import("./services/offer-inventories/definitions").GetOfferInventoriesResponse>;
+    getPaginatedOfferInventoriesV2({ page, size, sort, variantExternalId, }: import("./services/offer-inventories/definitions").GetPaginatedOfferInventoriesV2Parameters): Promise<import("./services/offer-inventories/definitions").GetOfferInventoriesV2Response>;
+    getOfferInventoryCustomFields({ externalId, page, size, sort, locale, }: import("./services/offer-inventories/definitions").GetOfferInventoryCustomFieldsParameters): Promise<import("./services/offer-inventories/definitions").GetOfferInventoryCustomFieldsResponse>;
+    getIncidents({ customerAccountIds, linkedType, ids, status, idType, page, size, sort, }: import("./services/incident/definitions").getIncidentsParameters): Promise<import("./services/incident/definitions").getIncidentsResponse>;
+    getIncidentsV2({ customerAccountIds, linkedType, ids, status, reasonCodes, supplierIds, customFields, idType, page, size, sort, }: import("./services/incident/definitions").getIncidentsParameters): Promise<import("./services/incident/definitions").getIncidentsResponse>;
+    getIncident({ incidentId, idType, }: import("./services/incident/definitions").getIncidentParameters): Promise<import("./services/incident/definitions").getIncidentResponse>;
+    createOrderLogisticIncident({ logisticOrderId, idType, customField, reasonCode, }: import("./services/incident/definitions").createOrderLogisticIncidentParameters): Promise<import("./services/incident/definitions").createOrderLogisticIncidentResponse>;
+    createOrderLogisticLineIncident({ logisticOrderId, idType, customFieldIdType, orderLines, reasonCode, }: import("./services/incident/definitions").createOrderLogisticLineIncidentParameters): Promise<import("./services/incident/definitions").createOrderLogisticLineIncidentResponse>;
+    createOrderLogisticIncidentThread({ logisticOrderId, incidentId, idType, customField, message, name, reasonCode, }: import("./services/incident/definitions").createOrderLogisticIncidentThreadParameters): Promise<import("./services/incident/definitions").createOrderLogisticIncidentThreadResponse>;
+    createIncident({ customField, externalId, logisticOrderId, reasonCodes, idType, }: import("./services/incident/definitions").createIncidentParameters): Promise<import("./services/incident/definitions").createIncidentResponse>;
+    getCommercialOrders({ locale, nbPreviewLines, page, size, sort, connectedUserOnly, customerAccountIds, sourceTypes, isValidated, }: import("./interfaces").GetCommercialOrdersParameters): Promise<import("./interfaces").GetCommercialOrdersResponse>;
+    getCommercialOrdersV2({ page, size, sort, locale, connectedUserOnly, customerAccountIds, sourceTypes, sourceIds, isValidated, nbPreviewLines, }: import("./interfaces").GetCommercialOrdersV2Parameters): Promise<import("./interfaces").GetCommercialOrdersV2Response>;
+    createCommercialOrder({ nbPreviewLines, channel, customFields, locale, origin, originId, paymentInfo, }: import("./interfaces").CreateCommercialOrderParameters): Promise<import("./interfaces").CreateCommercialOrderResponse>;
+    createCommercialOrderV2({ customFieldIdType, customFields, isFull, sourceId, sourceType, }: import("./interfaces").CreateCommercialOrderV2Parameters): Promise<import("./interfaces").CreateCommercialOrderV2Response>;
+    getCommercialOrder({ orderId, idType, locale, nbPreviewLines, }: import("./interfaces").GetCommercialOrderParameters): Promise<import("./interfaces").GetCommercialOrderResponse>;
+    updateCommercialOrder({ commercialOrderId, customFieldIdType, customFields, }: import("./interfaces").UpdateCommercialOrderParameters): Promise<void>;
+    createCommercialOrderCardRegistration({ orderId, paymentProvider, currency, }: import("./interfaces").CreateCommercialOrderCardRegistrationParameters): Promise<import("./interfaces").CreateCommercialOrderCardRegistrationResponse>;
+    updateCommercialOrderBillingInformation({ orderId, billingAddressId, }: import("./interfaces").UpdateCommercialOrderBillingInformationParameters): Promise<void>;
+    setCommercialOrderStatusAsCreated({ orderId, paymentInfo, }: import("./interfaces").SetCommercialOrderStatusAsCreatedParameters): Promise<void>;
+    setCommercialOrderStatusAsOnHold({ orderId, }: import("./interfaces").SetCommercialOrderStatusAsOnHoldParameters): Promise<void>;
+    syncCommercialOrder(orderId: string): Promise<void>;
+    getCommercialOrderPaymentPageUrl({ orderId, paymentOption, paymentProvider, }: import("./interfaces").GetCommercialOrderPaymentPageUrlParameters): Promise<string>;
+    createCommercialOrderPreauthorization({ orderId, paymentProvider, authorId, browserInfo, ipAddress, paymentCardInfo, }: import("./interfaces").CreateCommercialOrderPreauthorizationParameters): Promise<import("./interfaces").CreateCommercialOrderPreauthorizationResponse>;
+    updateCommercialOrderShippingAddress({ orderId, shippingAddressId, }: import("./interfaces").UpdateCommercialOrderShippingAddressParameters): Promise<void>;
+    updateCommercialOrderShippingInformation({ orderId, shippingAddressId, shippingType, }: import("./interfaces").UpdateCommercialOrderShippingInformationParameters): Promise<void>;
+    updateCommercialOrderShippingType({ orderId, shippingType, }: import("./interfaces").UpdateCommercialOrderShippingTypeParameters): Promise<void>;
+    deleteCommercialOrder(commercialOrderId: string): Promise<void>;
+    getCommercialOrderLines({ commercialOrderId, page, size, sort, supplierIds, productVariantIds, offerPriceIds, idType, locale, }: import("./interfaces").GetOrderCommercialLinesParameters): Promise<import("./interfaces").GetOrderCommercialLinesResponse>;
+    updateCommercialOrderLines({ commercialOrderId, customFieldIdType, lineIdType, lineType, updateOrderCommercialLines, metadata, }: import("./interfaces").UpdateCommercialOrderLinesParameters): Promise<import("./interfaces").UpdateCommercialOrderLinesResponse>;
+    deleteCommercialOrderLines({ commercialOrderId, body, }: import("./interfaces").DeleteCommercialOrderLinesParameters): Promise<import("./interfaces").DeleteCommercialOrderLinesResponse>;
+    punchoutOciCommercialOrder({ tenantConfigurationKey, commercialOrderId, locale, }: import("./interfaces").PunchoutOciCommercialOrderParameters): Promise<any>;
+    getLogisticOrders({ approvalIds, locale, logisticStatus, incident, paymentOptions, connectedUserOnly, nbPreviewLines, page, size, sort, suppliersIds, creationDateFrom, creationDateTo, updateDateFrom, updateDateTo, }: import("./interfaces").GetLogisticOrdersParameters): Promise<import("./interfaces").GetLogisticOrdersResponse>;
+    logisticOrdersPaginatedList({ page, size, sort, nbPreviewLines, accountCustomFieldValueCriteria, approvalIds, connectedUserOnly, creationDateFrom, creationDateTo, customerAccountIds, incident, locale, logisticStatus, offerCustomFieldValueCriteria, orderLogisticCustomFieldValueCriteria, paymentOptions, supplierIds, updateDateFrom, updateDateTo, }: import("./interfaces").GetPaginatedLogisticOrdersParameters): Promise<import("./interfaces").GetPaginatedLogisticOrdersResponse>;
+    getLogisticOrderCustomFields({ customFieldIds, page, size, sort, idType, }: import("./interfaces").GetLogisticOrderCustomFieldsParameters): Promise<import("./interfaces").GetLogisticOrderCustomFieldsResponse>;
+    getLogisticOrderLineCustomFields({ customFieldIds, page, size, sort, idType, }: import("./interfaces").GetLogisticOrderLineCustomFieldsParameters): Promise<import("./interfaces").GetLogisticOrderLineCustomFieldsResponse>;
+    getLogisticOrder({ orderId, locale, nbPreviewLines, }: import("./interfaces").GetLogisticOrderParameters): Promise<import("./interfaces").GetLogisticOrderResponse>;
+    updateLogisticOrderCustomFields({ orderId, locale, nbPreviewLines, customFields, }: import("./interfaces").UpdateLogisticOrderCustomFieldsParameters): Promise<import("./interfaces").UpdateLogisticOrderCustomFieldsResponse>;
+    getLogisticOrderAccountingDocuments({ orderId, }: import("./interfaces").GetLogisticOrderAccountingDocumentsParameters): Promise<import("./interfaces").GetLogisticOrderAccountingDocumentsResponse>;
+    getLogisticOrderAccountingDocumentUrl({ orderId, documentId, }: import("./interfaces").GetLogisticOrderAccountingDocumentUrlParameters): Promise<string[]>;
+    approveLogisticOrder({ orderId, locale, nbPreviewLines, }: import("./interfaces").ApproveLogisticOrderParameters): Promise<import("./interfaces").ApproveLogisticOrderResponse>;
+    getLogisticOrderApprovers({ orderId, }: import("./interfaces").GetLogisticOrderApproversParameters): Promise<import("./interfaces").GetLogisticOrderApproversResponse>;
+    updateLogisticOrderBillingInformation({ orderId, billingAddressId, }: import("./interfaces").UpdateLogisticOrderBillingInformationParameters): Promise<void>;
+    cancelLogisticOrder({ orderId, locale, nbPreviewLines, }: import("./interfaces").CancelLogisticOrderParameters): Promise<import("./interfaces").CancelLogisticOrderResponse>;
+    confirmLogisticOrderReception({ orderId, locale, nbPreviewLines, }: import("./interfaces").ConfirmLogisticOrderReceptionParameters): Promise<import("./interfaces").ConfirmLogisticOrderReceptionResponse>;
+    createLogisticOrder({ orderId, }: import("./interfaces").CreateLogisticOrderParameters): Promise<void>;
+    disapproveLogisticOrder({ orderId, locale, nbPreviewLines, }: import("./interfaces").DisapproveLogisticOrderParameters): Promise<import("./interfaces").DisapproveLogisticOrderResponse>;
+    getLogisticOrderDocuments({ orderId, idType, }: import("./interfaces").GetLogisticOrderDocumentsParameters): Promise<import("./interfaces").GetLogisticOrderDocumentsResponse>;
+    getLogisticOrderDocumentUrl({ orderId, documentId, }: import("./interfaces").GetLogisticOrderDocumentUrlParameters): Promise<string[]>;
+    getLogisticOrderLines({ orderId, page, size, sort, locale, }: import("./interfaces").GetLogisticOrderLinesParameters): Promise<import("./interfaces").GetLogisticOrderLinesResponse>;
+    updateOnHoldLogisticOrderLines({ orderId, lines, }: import("./interfaces").UpdateOnHoldLogisticOrderLinesParameters): Promise<import("./interfaces").UpdateOnHoldLogisticOrderLinesResponse>;
+    updateLogisticOrderLineCustomFields({ orderId, lineId, locale, customFields, }: import("./interfaces").UpdateLogisticOrderLineCustomFieldsParameters): Promise<import("./interfaces").UpdateLogisticOrderLineCustomFieldsResponse>;
+    updateOnHoldLogisticOrderLine({ orderId, orderLineId, quantity, }: import("./interfaces").UpdateOnHoldLogisticOrderLineParameters): Promise<void>;
+    updateLogisticOrderShippingAddress({ orderId, shippingAddressId, }: import("./interfaces").UpdateLogisticOrderShippingAddressParameters): Promise<void>;
+    getLogisticOrderShippingInformation({ orderId, }: import("./interfaces").GetLogisticOrderShippingAddressParameters): Promise<import("./interfaces").GetLogisticOrderShippingAddressResponse>;
+    updateLogisticOrderShippingInformation({ orderId, shippingAddressId, shippingType, }: import("./interfaces").UpdateLogisticOrderShippingInformationParameters): Promise<void>;
+    updateLogisticOrderShippingType({ orderId, shippingType, }: import("./interfaces").UpdateLogisticOrderShippingTypeParameters): Promise<void>;
+    createLogisticOrderThread({ orderId, lineId, message, reasonCode, }: import("./interfaces").CreateLogisticOrderThreadParameters): Promise<import("./interfaces").CreateLogisticOrderThreadResponse>;
+    createLogisticOrderThreadV2({ logisticOrderId, idType, message, reasonCode, }: import("./interfaces").CreateLogisticOrderThreadParametersV2): Promise<import("./interfaces").CreateLogisticOrderThreadResponseV2>;
+    getLogisticOrderThreads({ logisticOrderId, pageable, idType, }: import("./interfaces").GetLogisticOrderThreadsParams): Promise<import("./interfaces").GetLogisticOrderThreadsResponse>;
+    getLogisticOrderThread({ logisticOrderId, threadId, idType, }: import("./interfaces").GetLogisticOrderThreadParams): Promise<import("./interfaces").GetLogisticOrderThreadResponse>;
+    createOrderLogisticThreadMessages({ logisticOrderId, threadId, body, customField, idType, }: import("./interfaces").CreateLogisticOrderThreadMessagesParams): Promise<import("./interfaces").CreateLogisticOrderThreadMessagesResponse>;
+    updateOrderLogisticThreadMessage({ logisticOrderId, threadId, messageId, customFieldValues, idType, }: import("./interfaces").UpdateLogisticOrderThreadMessageParams): Promise<void>;
+    createLogisticOrderIncidentThreads({ logisticOrderId, incidentId, customField, message, name, reasonCode, idType, }: import("./interfaces").CreateLogisticOrderIncidentThreadsParams): Promise<import("./interfaces").CreateLogisticOrderIncidentThreadsResponse>;
+    getLogisticOrderIncidentThread({ logisticOrderId, incidentId, threadId, idType, }: import("./interfaces").GetLogisticOrderIncidentThreadParams): Promise<import("./interfaces").GetLogisticOrderIncidentThreadResponse>;
+    createLogisticOrderIncidentThreadMessages({ logisticOrderId, incidentId, threadId, body, customField, idType, }: import("./interfaces").CreateLogisticOrderIncidentThreadMessagesParams): Promise<import("./interfaces").CreateLogisticOrderIncidentThreadMessagesResponse>;
+    updateLogisticOrderIncidentThreadMessage({ logisticOrderId, incidentId, threadId, messageId, customFieldValues, idType, }: import("./interfaces").UpdateLogisticOrderIncidentThreadMessageParams): Promise<void>;
+    getLogisticOrderReview({ orderId, }: import("./interfaces").GetLogisticOrderReviewParameters): Promise<import("./interfaces").GetLogisticOrderReviewResponse>;
+    addLogisticOrderReview({ orderId, comment, grade, }: import("./interfaces").AddLogisticOrderReviewParameters): Promise<import("./interfaces").AddLogisticOrderReviewResponse>;
+    getThreadReasonTypes(): Promise<import("./interfaces").GetThreadReasonTypesResponse>;
+    getThreadSubReasons({ reasonType, }: import("./interfaces").GetThreadSubReasonsParameters): Promise<import("./interfaces").GetThreadSubReasonsResponse>;
+    getSuppliers({ pageable, supplierStatus, supplierIds, idType, }: import("./interfaces").GetSuppliersParameters): Promise<import("./interfaces").GetSuppliersResponse>;
+    getSupplier({ supplierId, idType, }: import("./interfaces").GetSupplierParameters): Promise<import("./interfaces").GetSupplierResponse>;
+    getSupplierEvaluations({ supplierId, idType, pageable, }: import("./interfaces").GetSupplierEvaluationsParameters): Promise<import("./interfaces").GetSupplierEvaluationsResponse>;
+    getMasterQuotes({ fromCustomerAccount, pageable, }?: import("./interfaces").GetMasterQuotesParameters): Promise<import("./interfaces").GetMasterQuotesResponse>;
+    createMasterQuote({ description, name, }: import("./interfaces").CreateMasterQuoteParameters): Promise<import("./interfaces").CreateMasterQuoteResponse>;
+    deleteMasterQuote({ masterQuoteId, }: import("./interfaces").DeleteMasterQuoteParameters): Promise<void>;
+    getMasterQuote({ masterQuoteId, }: import("./interfaces").GetMasterQuoteParameters): Promise<import("./interfaces").GetMasterQuoteResponse>;
+    updateMasterQuote({ masterQuoteId, customFieldValues, masterQuoteDetailsToAdd, masterQuoteDetailsToRemove, }: import("./interfaces").UpdateMasterQuoteParameters): Promise<import("./interfaces").UpdateMasterQuoteResponse>;
+    createSupplierQuotes({ billingAddressId, createSupplierQuoteRequests, masterQuoteId, supplierQuoteUrl, }: import("./interfaces").CreateSupplierQuotesParameters): Promise<import("./interfaces").CreateSupplierQuotesResponse>;
+    getSupplierQuote({ supplierQuoteId, }: import("./interfaces").GetSupplierQuoteParameters): Promise<import("./interfaces").GetSupplierQuoteResponse>;
+    acceptSupplierQuote({ supplierQuoteId, }: import("./interfaces").AcceptSupplierQuoteParameters): Promise<import("./interfaces").AcceptSupplierQuoteResponse>;
+    updateSupplierQuoteCustomFields({ supplierQuoteId, customFieldValues, idType, }: import("./interfaces").UpdateSupplierQuoteCustomFieldsParameters): Promise<import("./interfaces").UpdateSupplierQuoteCustomFieldsResponse>;
+    declineSupplierQuote({ supplierQuoteId, }: import("./interfaces").DeclineSupplierQuoteParameters): Promise<import("./interfaces").DeclineSupplierQuoteResponse>;
+    postMessageToSupplierQuote({ supplierQuoteId, message, username, }: import("./interfaces").PostMessageToSupplierQuoteParameters): Promise<import("./interfaces").PostMessageToSupplierQuoteResponse>;
+    initializeOrderFromSupplierQuote({ supplierQuoteId, nbPreviewLines, quoteLineIdsAndQuantities, }: import("./interfaces").InitializeOrderFromSupplierQuoteParameters): Promise<import("./interfaces").InitializeOrderFromSupplierQuoteResponse>;
+    getProductVariantsList({ productSku, locale, pageable, }: import("./services/product-variant/definitions").GetProductVariantsListParameters): Promise<import("./services/product-variant/definitions").GetProductVariantsListResponse>;
+    getProductVariantSuppliers({ productVariantId, }: import("./services/product-variant/definitions").GetProductVariantSuppliersParameters): Promise<import("./services/product-variant/definitions").GetProductVariantSuppliersResponse>;
+    getProductVariantAttributes({ productIdentifier, productIdType, locale, }: import("./services/product-variant/definitions").GetProductVariantAttributesParameters): Promise<import("./services/product-variant/definitions").GetProductVariantAttributesResponse>;
+    getProductVariant({ productVariantId, locale, }: import("./services/product-variant/definitions").GetProductVariantParameters): Promise<import("./services/product-variant/definitions").GetProductVariantResponse>;
+    autoCompleteSearchProducts({ input, locale, currency, pageable, aggregation, productTags, }: import("./interfaces").AutoCompleteSearchProductsParameters): Promise<import("./interfaces").SearchProductsResponse>;
+    getProductsList({ locale, filters, pageable, }: import("./interfaces").GetProductsListParameters): Promise<import("./interfaces").GetProductsListResponse>;
+    getProductVariantOffers({ productIdentifier, productIdType, currency, withoutPrice, }: import("./interfaces").GetProductVariantOffersParameters): Promise<import("./interfaces").GetProductVariantOffersResponse>;
+    getProduct({ productIdentifier, productIdType, locale, }: import("./interfaces").GetProductParameters): Promise<import("./interfaces").GetProductsListResponse>;
+    getProductOffers({ productIdentifier, productIdType, locale, currency, withoutPrice, }: import("./interfaces").GetProductOffersParameters): Promise<import("./interfaces").GetProductOffersResponse>;
+    getRelatedProducts({ productIdentifier, productIdType, locale, currency, pageable, }: import("./interfaces").GetRelatedProductsParameters): Promise<import("./interfaces").GetRelatedProductsResponse>;
+    getProductReviews({ productIdentifier, productIdType, }: import("./interfaces").GetProductReviewsParameters): Promise<import("./interfaces").GetProductReviewsResponse>;
+    getProductStatReviews({ productIdentifier, productIdType, }: import("./interfaces").GetProductStatReviewsParameters): Promise<import("./interfaces").GetProductStatReviewsResponse>;
+    createProductReview({ message, productSku, rating, }: import("./interfaces").CreateProductReviewParameters): Promise<import("./interfaces").CreateProductReviewResponse>;
+    updateProductReview({ productReviewId, message, rating, }: import("./interfaces").UpdateProductReviewParameters): Promise<import("./interfaces").UpdateProductReviewResponse>;
+    getProductPaginatedOffers({ productIdentifier, productIdType, currency, locale, withoutPrices, pageable, }: import("./interfaces").GetProductPaginatedOffersParameters): Promise<import("./interfaces").GetProductPaginatedOffersResponse>;
+    getNavigationCategories({ locale, }: import("./interfaces").GetNavigationCategoriesParameters): Promise<import("./interfaces").GetNavigationCategoriesResponse>;
+    getNavigationCategory({ locale, idType, navigationCategoryId, }: import("./interfaces").GetNavigationCategoryParameters): Promise<import("./interfaces").GetNavigationCategoryResponse>;
+    getNavigationCategoryBreadcrumbs({ locale, idType, navigationCategoryId, }: import("./interfaces").GetNavigationCategoryBreadcrumbsParameters): Promise<import("./interfaces").GetNavigationCategoryBreadcrumbsResponse>;
+    getNavigationCategoryByOptions(params?: import("./interfaces").GetNavigationCategoryByOptionsParameters): Promise<import("./interfaces").GetNavigationCategoriesResponse>;
+    getAuthenticatedUser(): Promise<import("./interfaces").GetAuthenticatedUserResponse>;
+    createCustomerUser(params: import("./interfaces").CreateCustomerUserParameters): Promise<import("./interfaces").CreateCustomerUserResponse>;
+    updateCustomerUser({ civility, firstName, lastName, phone, customFieldValues, }: import("./interfaces").UpdateCustomerUserParameters): Promise<import("./interfaces").UpdateCustomerUserResponse>;
+    activateCustomerUser(params: import("./interfaces").ActivateCustomerUserParameters): Promise<void>;
+    getCustomerUserAddresses({ shipping, billing, account, organisationIds, }: import("./interfaces").GetCustomerUserAddressesParameters): Promise<void>;
+    getCustomerUserOrganisations(): Promise<import("./interfaces").GetCustomerUserOrganisationsResponse>;
+    sendCustomerUserActivationRequest({ redirectUrl, token, }: import("./interfaces").SendCustomerUserActivationRequestParameters): Promise<void>;
+    updateSpecificCustomerUser({ userToUpdateId, civility, firstName, lastName, phone, groups, customFieldValues, idType, }: import("./interfaces").UpdateSpecificCustomerUserParameters): Promise<void>;
+    removeAccountsFromCustomerUser({ userToUpdateId, idType, accountIds, }: import("./interfaces").RemoveAccountsFromCustomerUserParameters): Promise<void>;
+    addCustomerUserToAccounts({ userToUpdateId, idType, accountIds, }: import("./interfaces").AddCustomerUserToAccountsParameters): Promise<void>;
+    getCustomerAccount(config?: import("./interfaces").DjustConfig): Promise<import("./interfaces").GetCustomerAccountResponse>;
+    getCustomerAccountV2(pageable: import("./interfaces").PageableParameters): Promise<import("./interfaces").GetCustomerAccountResponseV2>;
+    createCustomerAccount({ createAddressRequests, createCustomerUserRequest, createObjectCustomerAccountRequest, customFieldValues, customerTagList, fromFO, legalUser, ...config }: import("./interfaces").CreateCustomerAccountParameters & import("./interfaces").DjustConfig): Promise<import("./interfaces").CreateCustomerAccountResponse>;
+    updateCustomerAccount({ accountManager, businessRegistrationNumber, companyRegistrationName, customFieldValues, customerTagList, legalUser, name, vatNumber, website, ...config }: import("./interfaces").UpdateCustomerAccountParameters & import("./interfaces").DjustConfig): Promise<import("./interfaces").UpdateCustomerAccountResponse>;
+    getCustomerAccountAddresses(params: import("./interfaces").GetCustomerAccountAddressesParameters & import("./interfaces").DjustConfig): Promise<import("./interfaces").GetCustomerAccountAddressesResponse>;
+    createCustomerAccountAddress(params: import("./interfaces").CreateCustomerAccountAddressParameters & import("./interfaces").DjustConfig): Promise<import("./interfaces").CreateCustomerAccountAddressResponse>;
+    deleteCustomerAccountAddress({ addressId, ...config }: import("./interfaces").DeleteCustomerAccountAddressParameters & import("./interfaces").DjustConfig): Promise<void>;
+    updateCustomerAccountAddress({ addressId, additionalAddress, address, billing, city, company, country, fullName, label, phone, shipping, state, zipcode, ...config }: import("./interfaces").UpdateCustomerAccountAddressParameters & import("./interfaces").DjustConfig): Promise<import("./interfaces").UpdateCustomerAccountAddressResponse>;
+    getCustomerAccountCustomFields({ customFieldIds, idType, pageable, }: import("./interfaces").GetCustomerAccountCustomFieldsParameters): Promise<import("./interfaces").GetCustomerAccountCustomFieldsResponse>;
+    getCustomerAccountOrders(params: import("./interfaces").GetCustomerAccountOrdersParameters & import("./interfaces").DjustConfig): Promise<import("./interfaces").GetCustomerAccountOrdersResponse>;
+    getCustomerAccountUsers(params: import("./interfaces").GetCustomerAccountUsersParameters & import("./interfaces").DjustConfig): Promise<import("./interfaces").GetCustomerAccountUsersResponse>;
+    createCustomerAccountOrganisation(params: import("./interfaces").CreateCustomerAccountOrganisationParameters & import("./interfaces").DjustConfig): Promise<import("./interfaces").CreateCustomerAccountOrganisationResponse>;
+    updateCustomerAccountOrganisation(params: import("./interfaces").UpdateCustomerAccountOrganisationParameters & import("./interfaces").DjustConfig): Promise<import("./interfaces").UpdateCustomerAccountOrganisationResponse>;
+    getCustomerAccountOrganisations(params?: {
+        pageable?: import("./interfaces").PageableParameters;
+    } & import("./interfaces").DjustConfig): Promise<import("./interfaces").GetCustomerAccountOrganisationResponse>;
+    getCustomerAccountOrganisationAddresses(params: import("./interfaces").GetCustomerAccountOrganisationAddressesParameters & import("./interfaces").DjustConfig): Promise<import("./interfaces").GetCustomerAccountOrganisationAddressesResponse>;
+    deleteCustomerAccountOrganisationAddress(params: import("./interfaces").DeleteCustomerAccountOrganisationAddressParameters & import("./interfaces").DjustConfig): Promise<void>;
+    updateCustomerAccountOrganisationAddress(params: import("./interfaces").UpdateCustomerAccountOrganisationAddressParameters & import("./interfaces").DjustConfig): Promise<import("./interfaces").UpdateCustomerAccountOrganisationAddressResponse>;
+    getCustomerAccountOrganisationOrders(params: import("./interfaces").GetCustomerAccountOrganisationOrdersParameters & import("./interfaces").DjustConfig): Promise<import("./interfaces").GetCustomerAccountOrganisationOrdersResponse>;
+    getCustomerAccountOrganisationUsers(params: import("./interfaces").GetCustomerAccountOrganisationUsersParameters & import("./interfaces").DjustConfig): Promise<import("./interfaces").GetCustomerAccountOrganisationUsersResponse>;
+    updateCustomerAccountOrganisationUser(params: import("./interfaces").UpdateCustomerAccountOrganisationUserParameters & import("./interfaces").DjustConfig): Promise<import("./interfaces").UpdateCustomerAccountOrganisationUserResponse>;
+    deleteCarts(): Promise<import("./interfaces").DeleteCartsResponse>;
+    getCarts(params: import("./interfaces").GetCartsParameters): Promise<import("./interfaces").GetCartsResponse>;
+    createCart(params: import("./interfaces").CreateCartParameters): Promise<import("./interfaces").CreateCartResponse>;
+    deleteCart(params: import("./interfaces").DeleteCartParameters): Promise<void>;
+    getCart(params: import("./interfaces").GetCartParameters): Promise<import("./interfaces").GetCartResponse>;
+    updateCart(params: import("./interfaces").UpdateCartParameters): Promise<void>;
+    initializeOrdersFromCart(params: import("./interfaces").InitializeOrdersFromCartParameters): Promise<string>;
+    deleteCartLines(params: import("./interfaces").DeleteCartLinesParameters): Promise<import("./interfaces").DeleteCartLinesResponse>;
+    getCartLines(params: import("./interfaces").GetCartLinesParameters): Promise<import("./interfaces").GetCartLinesResponse>;
+    updateCartLines(params: import("./interfaces").UpdateCartLinesParameters): Promise<import("./interfaces").UpdateCartLinesResponse>;
+    updateCartLinesByVariant(params: import("./interfaces").UpdateCartLinesByVariantParameters): Promise<import("./interfaces").UpdateCartLinesByVariantResponse>;
+    isTokenValid({ token, }: import("./services/auth/definitions.requests").IsTokenValidParameters): Promise<boolean>;
+    refreshToken({ refreshToken, }: import("./services/auth/definitions.requests").RefreshTokenParameters): Promise<import("./interfaces").RefreshTokenResponse>;
+    resetPassword({ newPassword, resetPasswordToken, }: import("./services/auth/definitions.requests").ResetPasswordParameters): Promise<void>;
+    sendResetPasswordEmail({ email, }: import("./services/auth/definitions.requests").SendResetPasswordEmailParameters): Promise<void>;
+    login({ username, password, withUser, }: import("./services/auth/definitions.requests").LoginParameters): Promise<import("./interfaces").LoginResponse>;
+    logout(): Promise<void>;
+    getSettings(): Promise<import("./interfaces").SettingsResponse>;
+    getStore({ storeId, }: import("./services/auth/definitions.requests").GetStoreParameters): Promise<import("./interfaces").Store>;
+};
+/**
+ * Creates a new DJUST SDK client with isolated state.
+ *
+ * This is the recommended API for SSR environments (Nuxt, Nitro, Next.js).
+ * Each call to `withContext()` returns an isolated client that does not
+ * share state with other requests.
+ *
+ * @example
+ * ```typescript
+ * // Create client once at app initialization
+ * const djust = createDjustClient({
+ *   baseUrl: 'https://api.djust.io',
+ *   clientId: 'your-client-id',
+ *   apiKey: 'your-api-key',
+ *   timeout: 30000,
+ *   strictErrors: true,
+ * });
+ *
+ * // In SSR request handler
+ * export default defineEventHandler(async (event) => {
+ *   const sdk = djust.withContext({
+ *     accessToken: getCookie(event, 'token'),
+ *     customerAccountId: getCookie(event, 'customer-account-id'),
+ *     requestId: getRequestHeader(event, 'x-request-id'),
+ *   });
+ *
+ *   return await sdk.getCart({ cartId: '123', currency: 'EUR' });
+ * });
+ * ```
+ *
+ * @since 2.17.0
+ */
+export { createDjustClient } from "./client";
+export type { DjustClientConfig, DjustClient, DjustScopedClient, RequestContext, RetryConfig, TransportHooks, } from "./client";
+export { SDKError, SDKErrorCode, RETRIABLE_ERROR_CODES, RETRIABLE_HTTP_STATUS_CODES, ValidationError, AuthError, ForbiddenError, NotFoundError, RateLimitError, NetworkError, TimeoutError, ServerError, UnexpectedError, createErrorFromResponse, createErrorFromException, isSDKError, isAuthError, isForbiddenError, isNetworkError, isTimeoutError, isServerError, isValidationError, isNotFoundError, isRateLimitError, isUnexpectedError, isRetryable, getRetryDelay, shouldReauthenticate, isClientError, isTransientError, extractStatusCode, extractErrorCode, getUserFriendlyMessage, toLegacyError, fromLegacyError, isLegacyError, parseLegacyError, withLegacyErrors, withStructuredErrors, isApiError, getHttpStatus, } from "./errors";
+export type { SDKErrorCodeType, SDKErrorOptions, RequestMetadata, ErrorFactoryOptions, SerializedError, ClientSafeError, } from "./errors";
+export * from "./interfaces";
+//# 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":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAwBH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,QAAQ;IAiBnB;;OAEG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA2H+usB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;CAzHpvsB,CAAC;AAMF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,YAAY,EACV,iBAAiB,EACjB,WAAW,EACX,iBAAiB,EACjB,cAAc,EACd,WAAW,EACX,cAAc,GACf,MAAM,UAAU,CAAC;AAMlB,OAAO,EAEL,QAAQ,EACR,YAAY,EACZ,qBAAqB,EACrB,2BAA2B,EAG3B,eAAe,EACf,SAAS,EACT,cAAc,EACd,aAAa,EACb,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,eAAe,EAGf,uBAAuB,EACvB,wBAAwB,EAGxB,UAAU,EACV,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EAGjB,WAAW,EACX,aAAa,EACb,oBAAoB,EACpB,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,sBAAsB,EAGtB,aAAa,EACb,eAAe,EACf,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACpB,UAAU,EACV,aAAa,GACd,MAAM,UAAU,CAAC;AAElB,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,mBAAmB,EACnB,eAAe,EACf,eAAe,GAChB,MAAM,UAAU,CAAC;AAMlB,cAAc,cAAc,CAAC"}