@salesforce/commerce-sdk-react 1.0.0-preview.0

package/.eslintrc.js

@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2021, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+module.exports = {
+    extends: [require.resolve('@salesforce/pwa-kit-dev/configs/eslint')]
+}

package/CHANGELOG.md

@@ -0,0 +1,35 @@
+## v1.0.0-preview.0 (May 31, 2023)
+## v1.0.0-dev (May 29, 2023)
+## v3.0.0-dev (May 12, 2023)
+
+- Add missing cache invalidation for contexts/customers/login/order [#1073](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/1073)
+
+- Upgrade React 18, React DOM 18, @types/react@18, @types/react-dom@v18 Testing library 14 [#1166](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/1166)
+
+## v2.7.1 (May 11, 2023)
+
+-   Re-generate lock files and fix hook lib tests [#1186](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/1186)
+-   Add additional properties to ShopperLogin test types [#1185](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/1185)
+-   Add missing cache invalidation for contexts/customers/login/order [#1073](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/1073)
+-   Fix Shopper Baskets Test case [#1082](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/1082)
+-   Implement remaining Shopper Baskets cache logic [#1070](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/1070)
+-   Decode pre-fetched token and save auth data in storage [#1052](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/1052)
+-   Allow query hook parameters to be null. [#1046](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/1046)
+-   Implement updateCustomerPassword as no-op. [#1031](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/1031)
+
+## v2.7.0 (Mar 03, 2023)
+
+-   Add Page/Region/Component components for shopper experience/page designer page rendering [#963](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/963)
+-   Namespace `Auth` storage keys with site identifier to allow multi-site support [#911](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/911)
+-   Add Shopper Experience `usePage` and `usePages` hooks[#958](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/958)
+
+## v2.6.0 (Jan 25, 2023)
+
+## v2.5.0 (Jan 05, 2023)
+
+-   Exclude test files in package file to avoid publishing them [#856](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/856)
+-   Pass in 'headers' and 'rawResponse' options to mutation hooks [#845](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/845)
+-   Commerce hooks: basket mutations [#834](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/834)
+-   Remove overriding of params in mutation hooks [#859](https://github.com/SalesforceCommerceCloud/pwa-kit/pull/859)
+
+## v2.4.0 (Dec 01, 2022)

package/LICENSE

@@ -0,0 +1,14 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, Salesforce.com, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of Salesforce.com nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,327 @@
+# Commerce SDK React
+
+<p align="center">
+A collection of <a href="https://tanstack.com/query/latest/docs/react/overview">react-query</a> hooks for <b>fetching</b>, <b>caching</b>, and <b>mutating data</b> from the <b><a href="https://developer.salesforce.com/docs/commerce/commerce-api/overview">Salesforce B2C Commerce API</a></b> (SCAPI).</p>
+
+## 🎯 Features
+
+- Shopper authentication & token management via [SLAS](https://developer.salesforce.com/docs/commerce/commerce-api/references/shopper-login)
+- Server side data fetching (in conjuction with PWA Kit)
+- Phased Launch support ([plugin_slas](https://github.com/SalesforceCommerceCloud/plugin_slas) compatible)
+- Built-in caching for easy state management
+  - automatic cache invalidations/updates via the library's built-in mutations
+  - automatic cache key generation
+
+## ⚙️ Installation
+
+```bash
+npm install @salesforce/commerce-sdk-react @tanstack/react-query
+```
+
+## ⚡️ Quickstart (PWA Kit v2.3.0+)
+
+To integrate this library with your PWA Kit application you can use the `CommerceApiProvider` directly assuming that you use the `withReactQuery` higher order component to wrap your `AppConfig` component. Below is a snippet of how this is accomplished.
+
+```jsx
+// app/components/_app-config/index.jsx
+
+import {CommerceApiProvider} from '@salesforce/commerce-sdk-react'
+import {withReactQuery} from '@salesforce/pwa-kit-react-sdk/ssr/universal/components/with-react-query'
+
+const AppConfig = ({children}) => {
+    return (
+        <CommerceApiProvider
+            clientId="12345678-1234-1234-1234-123412341234"
+            organizationId="f_ecom_aaaa_001"
+            proxy="localhost:3000/mobify/proxy/api"
+            redirectURI="localhost:3000/callback"
+            siteId="RefArch"
+            shortCode="12345678"
+            locale="en-US"
+            currency="USD"
+        >
+            {children}
+        </CommerceApiProvider>
+    )
+} 
+
+// Set configuration options for react query.
+// NOTE: This configuration will be used both on the server-side and client-side.
+const options = {
+    queryClientConfig: {
+        defaultOptions: {
+            queries: {
+                retry: false
+            },
+            mutations: {
+                retry: false
+            }
+        }
+    }
+}
+
+export default withReactQuery(AppConfig, options)
+```
+
+## ⚡️ Quickstart (Generic React App)
+
+You can use this library in any React application by creating a new QueryClient and wrap your application with `QueryClientProvider`. For example: 
+
+```jsx
+import {CommerceApiProvider} from '@salesforce/commerce-sdk-react'
+import {QueryClient, QueryClientProvider} from '@tanstack/react-query'
+
+
+const App = ({children}) => {
+    const queryClient = new QueryClient()
+
+    return (
+        <QueryClientProvider client={queryClient}>
+            <CommerceApiProvider
+                clientId="12345678-1234-1234-1234-123412341234"
+                organizationId="f_ecom_aaaa_001"
+                proxy="localhost:3000/mobify/proxy/api"
+                redirectURI="localhost:3000/callback"
+                siteId="RefArch"
+                shortCode="12345678"
+                locale="en-US"
+                currency="USD"
+            >
+                {children}
+            </CommerceApiProvider>
+        </QueryClientProvider>
+    )
+} 
+
+export default App
+```
+
+## Shopper Authentication and Token Management
+
+_💡 This section assumes you have read and completed the [Authorization for Shopper APIs](https://developer.salesforce.com/docs/commerce/commerce-api/guide/authorization-for-shopper-apis.html) guide._
+
+To help reduce boilerplate code for managing shopper authentication, by default, this library automatically initializes shopper session and manages the tokens for developers. Currently, the library supports the [Public Client login flow](https://developer.salesforce.com/docs/commerce/commerce-api/guide/slas-public-client.html).
+
+### Shopper Session Initialization
+
+On `CommerceApiProvider` mount, the provider initializes shopper session by initiating the SLAS __Public Client__ login flow. The tokens are stored/managed/refreshed by the library.
+
+### Authenticate request queue
+
+While the library is fetching/refreshing the access token, the network requests will queue up until there is a valid access token.
+
+### Login helpers
+
+To leverage the managed shopper authentication feature, use the `useAuthHelper` hook for shopper login.
+
+Example:
+
+```jsx
+import {AuthHelpers, useAuthHelper} from '@salesforce/commerce-sdk-react'
+
+const Example = () => {
+    const register = useAuthHelper(AuthHelpers.Register)
+    const login = useAuthHelper(AuthHelpers.LoginRegisteredUserB2C)
+    const logout = useAuthHelper(AuthHelpers.LogOut)
+
+    return <button onClick={() => {
+        login.mutate({username: 'kevin', password: 'pa$$word'})
+    }}>
+}
+```
+
+### Externally Managed Shopper Authentication
+
+You have the option of handling shopper authentication externally, by providing a SLAS access token. This is useful if you plan on using this library in an application where the authentication mechanism is different.
+
+```jsx
+const MyComponent = ({children}) => {
+    return (
+        <CommerceApiProvider fetchedToken="xxxxxxxxxxxx">
+            {children}
+        </CommerceApiProvider>
+    )
+} 
+```
+
+## Hooks
+
+The majority of hooks provided in this library are built on top of the [useQuery](https://tanstack.com/query/latest/docs/react/reference/useQuery) and the [useMutation](https://tanstack.com/query/latest/docs/react/reference/useMutation) hook from [react-query](https://tanstack.com/query/latest). React-query provides a declarative way for fetching and updating data. This library takes advantage of the features provided by react-query and combine with the [commerce-sdk-isomorphic](https://github.com/SalesforceCommerceCloud/commerce-sdk-isomorphic) API client to create a collection of hooks to simplify data fetching for SCAPI.
+
+The hooks can be categorized into __Query hooks__ and __Mutation hooks__.
+
+### Query hooks
+
+The query hooks correspond to the http GET endpoints from the SCAPI. The query hooks follow the signature pattern:
+
+```
+use<EntityName>(CommerceClientOptions, ReactQueryOptions)
+```
+
+Both the __required__ and __optional__ parameters for the underlying `commerce-sdk-isomorphic` call is passed as the first parameter:
+
+```jsx
+import {useProduct} from '@salesforce/commerce-sdk-react'
+
+const Example = () => {
+    const query = useProduct({
+        parameters: {
+            id: '25592770M',
+            locale: 'en-US'
+        }
+    })
+
+    return <>
+        <p>isLoading: {query.isLoading}</p>
+        <p>name: {query.data?.name}</p>
+    </>
+}
+```
+
+The second parameter is the react-query query options, for more detail, read [useQuery reference](https://tanstack.com/query/latest/docs/react/reference/useQuery).
+
+```jsx
+import {useBasket} from '@salesforce/commerce-sdk-react'
+
+const onServer = typeof window === undefined
+
+const Example = ({basketId}) => {
+    const query = useBasket({
+        parameters: {
+            basketId: basketId
+        },
+    }, {
+        // A common use case for `enabled` is
+        // to conditionally fetch based on environment
+        enabled: !onServer && basketId
+    })
+}
+```
+
+### Mutation hooks
+
+The query hooks correspond to the http POST, PUT, PATCH, DELETE endpoints from the SCAPI. The mutation hooks follow the signature pattern:
+
+```
+use<ApiName>Mutation(EndpointName)
+```
+
+For example, the [ShopperBaskets API](https://developer.salesforce.com/docs/commerce/commerce-api/references/shopper-baskets?meta=Summary) has a number of endpoints, one of them being the [addItemToBasket](https://developer.salesforce.com/docs/commerce/commerce-api/references/shopper-baskets?meta=addItemToBasket) endpoint (`POST /baskets/{basketId}/items`).
+
+```jsx
+import {useShopperBasketsMutation} from '@salesforce/commerce-sdk-react'
+
+const Example = ({basketId}) => {
+    // Typescript IDE intellisense for available options
+    const addItemToBasket = useShopperBasketsMutation('addItemToBasket')
+
+    return <button onClick={() => addItemToBasket.mutate({
+        parameters: {
+            basketId
+        },
+        body: {
+            productId: '25592770M',
+            price: 55,
+            quantity: 1
+        }
+    })} />
+}
+```
+
+You could also import the mutation options as a constant like:
+
+```jsx
+import {useShopperBasketsMutation, ShopperBasketsMutations} from '@salesforce/commerce-sdk-react'
+
+const Example = ({basketId}) => {
+    const addItemToBasket = useShopperBasketsMutation(ShopperBasketsMutations.AddItemToBasket)
+    return ...
+}
+```
+
+### Cache Invalidations and Updates
+
+Since mutations changes data on the server, the cache entries that are potentially affected by the mutation is automatically invalidated.
+
+For example, an `addItemToBasket` mutation automatically update `useBasket`  and `useCustomerBaskets` query cache, because the mutation result contains the information for the updated basket. In other cases, when the mutation response do not have the updated data, the library will invalidate the cache and trigger a re-fetch. For the DELETE endpoints, the library removes the cache entries on successful mutations.
+
+_💡 Debugging hint: install and include `@tanstack/react-query-devtools` in your React app to see the queries (inspect the query states and cache keys)._
+
+## Ultilities
+
+Besides the collection of query hooks and mutation hooks, here are some ultility hooks to help you interact with SCAPI.
+
+### `useCommerceApi()`
+
+This hook returns a set of SCAPI clients, which are already initialized using the configurations passed to the provider. Note: this hook doesn't automatically include auth headers.
+
+```jsx
+import {useCommerceApi, useAccessToken} from '@salesforce/commerce-sdk-react'
+
+const Example = () => {
+    const api = useCommerceApi()
+    const {getTokenWhenReady} = useAccessToken()
+
+    const fetchProducts = async () => {
+        const token = await getTokenWhenReady()
+        const products = await api.shopperProducts.getProducts({
+                parameters: {ids: ids.join(',')},
+                headers: {
+                    Authorization: `Bearer ${token}`
+                }
+            })
+        return products
+    }
+
+}
+```
+
+### `useAccessToken()`
+
+```ts
+useAccessToken() => {token: String, getTokenWhenReady: Promise}
+```
+
+This ultility hook give access to the managed SLAS access token.
+
+### `useCustomerId()`
+
+```ts
+useCustomerId() => null | string
+```
+
+### `useCustomerType()`
+
+```ts
+useCustomerId() => null | 'guest' | 'registered'
+```
+
+### `useEncUserId()`
+
+```ts
+useEncUserId() => null | string
+```
+
+### `useUsid()`
+
+```ts
+useUsid() => null | string
+```
+
+## Roadmap
+- Optimistic update support
+- SLAS private client support
+
+## Useful Links:
+
+-   [Get Started](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/getting-started.html)
+-   [Skills for Success](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/skills-for-success.html)
+-   [Set Up API Access](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/setting-up-api-access.html)
+-   [Configuration Options](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/configuration-options.html)
+-   [Proxy Requests](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/proxying-requests.html)
+-   [Push and Deploy Bundles](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/pushing-and-deploying-bundles.html)
+-   [The Retail React App](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/retail-react-app.html)
+-   [Rendering](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/rendering.html)
+-   [Routing](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/routing.html)
+-   [Phased Headless Rollouts](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/phased-headless-rollouts.html)
+-   [Launch Your Storefront](https://developer.salesforce.com/docs/commerce/pwa-kit-managed-runtime/guide/launching-your-storefront.html)

package/auth/index.d.ts

@@ -0,0 +1,220 @@
+import { helpers, ShopperLoginTypes, ShopperCustomersTypes } from 'commerce-sdk-isomorphic';
+import { ApiClientConfigParams, Prettify, RemoveStringIndex } from '../hooks/types';
+import { CustomerType } from '../hooks/useCustomerType';
+declare type TokenResponse = ShopperLoginTypes.TokenResponse;
+declare type Helpers = typeof helpers;
+interface AuthConfig extends ApiClientConfigParams {
+    redirectURI: string;
+    proxy: string;
+    fetchOptions?: ShopperLoginTypes.FetchOptions;
+    fetchedToken?: string;
+    OCAPISessionsURL?: string;
+}
+/**
+ * The extended field is not from api response, we manually store the auth type,
+ * so we don't need to make another API call when we already have the data.
+ * Plus, the getCustomer endpoint only works for registered user, it returns a 404 for a guest user,
+ * and it's not easy to grab this info in user land, so we add it into the Auth object, and expose it via a hook
+ */
+export declare type AuthData = Prettify<RemoveStringIndex<TokenResponse> & {
+    customer_type: CustomerType;
+    idp_access_token: string;
+}>;
+/** A shopper could be guest or registered, so we store the refresh tokens individually. */
+declare type AuthDataKeys = Exclude<keyof AuthData, 'refresh_token'> | 'refresh_token_guest' | 'refresh_token_registered';
+/**
+ * This class is used to handle shopper authentication.
+ * It is responsible for initializing shopper session, manage access
+ * and refresh tokens on server/browser environments. As well as providing
+ * a mechanism to queue network calls before having a valid access token.
+ *
+ * @Internal
+ */
+declare class Auth {
+    private client;
+    private shopperCustomersClient;
+    private redirectURI;
+    private pendingToken;
+    private REFRESH_TOKEN_EXPIRATION_DAYS;
+    private stores;
+    private fetchedToken;
+    private OCAPISessionsURL;
+    constructor(config: AuthConfig);
+    get(name: AuthDataKeys): string;
+    private set;
+    private clearStorage;
+    /**
+     * Every method in this class that returns a `TokenResponse` constructs it via this getter.
+     */
+    private get data();
+    /**
+     * Used to validate JWT token expiration.
+     */
+    private isTokenExpired;
+    /**
+     * This method stores the TokenResponse object retrived from SLAS, and
+     * store the data in storage.
+     */
+    private handleTokenResponse;
+    /**
+     * This method queues the requests and handles the SLAS token response.
+     *
+     * It returns the queue.
+     *
+     * @Internal
+     */
+    queueRequest(fn: () => Promise<TokenResponse>, isGuest: boolean): Promise<ShopperLoginTypes.TokenResponse>;
+    /**
+     * The ready function returns a promise that resolves with valid ShopperLogin
+     * token response.
+     *
+     * When this method is called for the very first time, it initializes the session
+     * by following the public client auth flow to get access token for the user.
+     * The flow:
+     * 1. If we have valid access token - use it
+     * 2. If we have valid refresh token - refresh token flow
+     * 3. PKCE flow
+     */
+    ready(): Promise<ShopperLoginTypes.TokenResponse>;
+    /**
+     * Creates a function that only executes after a session is initialized.
+     * @param fn Function that needs to wait until the session is initialized.
+     * @returns Wrapped function
+     */
+    whenReady<Args extends unknown[], Data>(fn: (...args: Args) => Promise<Data>): (...args: Args) => Promise<Data>;
+    /**
+     * A wrapper method for commerce-sdk-isomorphic helper: loginGuestUser.
+     *
+     */
+    loginGuestUser(): Promise<ShopperLoginTypes.TokenResponse>;
+    /**
+     * This is a wrapper method for ShopperCustomer API registerCustomer endpoint.
+     *
+     */
+    register(body: ShopperCustomersTypes.CustomerRegistration): Promise<{
+        addresses?: ({
+            address1?: string | undefined;
+            address2?: string | undefined;
+            addressId: string;
+            city?: string | undefined;
+            companyName?: string | undefined;
+            countryCode: string;
+            creationDate?: any;
+            firstName?: string | undefined;
+            fullName?: string | undefined;
+            jobTitle?: string | undefined;
+            lastModified?: any;
+            lastName: string;
+            phone?: string | undefined;
+            postBox?: string | undefined;
+            postalCode?: string | undefined;
+            preferred?: boolean | undefined;
+            salutation?: string | undefined;
+            secondName?: string | undefined;
+            stateCode?: string | undefined;
+            suffix?: string | undefined;
+            suite?: string | undefined;
+            title?: string | undefined;
+        } & {
+            [key: string]: any;
+        })[] | undefined;
+        authType?: string | undefined;
+        birthday?: any;
+        companyName?: string | undefined;
+        creationDate?: any;
+        customerId?: string | undefined;
+        customerNo?: string | undefined;
+        email?: string | undefined;
+        enabled?: boolean | undefined;
+        fax?: string | undefined;
+        firstName?: string | undefined;
+        gender?: number | undefined;
+        jobTitle?: string | undefined;
+        lastLoginTime?: any;
+        lastModified?: any;
+        lastName?: string | undefined;
+        lastVisitTime?: any;
+        login?: string | undefined;
+        note?: string | undefined;
+        paymentInstruments?: ({
+            bankRoutingNumber?: string | undefined;
+            creationDate?: any;
+            lastModified?: any;
+            maskedGiftCertificateCode?: string | undefined;
+            paymentBankAccount: {
+                driversLicenseLastDigits?: string | undefined;
+                driversLicenseStateCode?: string | undefined;
+                holder?: string | undefined;
+                maskedDriversLicense?: string | undefined;
+                maskedNumber?: string | undefined;
+                numberLastDigits?: string | undefined;
+            } & {
+                [key: string]: any;
+            };
+            paymentCard: {
+                cardType: string;
+                creditCardExpired?: boolean | undefined;
+                creditCardToken?: string | undefined;
+                expirationMonth?: number | undefined;
+                expirationYear?: number | undefined;
+                holder?: string | undefined;
+                issueNumber?: string | undefined;
+                maskedNumber?: string | undefined;
+                numberLastDigits?: string | undefined;
+                validFromMonth?: number | undefined;
+                validFromYear?: number | undefined;
+            } & {
+                [key: string]: any;
+            };
+            paymentInstrumentId: string;
+            paymentMethodId: string;
+        } & {
+            [key: string]: any;
+        })[] | undefined;
+        phoneBusiness?: string | undefined;
+        phoneHome?: string | undefined;
+        phoneMobile?: string | undefined;
+        preferredLocale?: string | undefined;
+        previousLoginTime?: any;
+        previousVisitTime?: any;
+        salutation?: string | undefined;
+        secondName?: string | undefined;
+        suffix?: string | undefined;
+        title?: string | undefined;
+    } & {
+        [key: string]: any;
+    }>;
+    /**
+     * A wrapper method for commerce-sdk-isomorphic helper: loginRegisteredUserB2C.
+     *
+     */
+    loginRegisteredUserB2C(credentials: Parameters<Helpers['loginRegisteredUserB2C']>[1]): Promise<helpers.TokenResponse>;
+    /**
+     * A wrapper method for commerce-sdk-isomorphic helper: logout.
+     *
+     */
+    logout(): Promise<ShopperLoginTypes.TokenResponse>;
+    /**
+     * Make a post request to the OCAPI /session endpoint to bridge the session.
+     *
+     * The HTTP response contains a set-cookie header which sets the dwsid session cookie.
+     * This cookie is used on SFRA, and it allows shoppers to navigate between SFRA and
+     * this PWA site seamlessly; this is often used to enable hybrid deployment.
+     *
+     * (Note: this method is client side only, b/c MRT doesn't support set-cookie header right now)
+     *
+     * @returns {Promise}
+     */
+    createOCAPISession(): Promise<Response>;
+    /**
+     * Decode SLAS JWT and extract information such as customer id, usid, etc.
+     *
+     */
+    parseSlasJWT(jwt: string): {
+        isGuest: boolean;
+        customerId: string;
+        usid: string;
+    };
+}
+export default Auth;
+//# sourceMappingURL=index.d.ts.map