@scayle/storefront-core 8.9.0 → 8.11.0

package/dist/rpc/methods/checkout/checkout.d.ts

@@ -1,13 +1,53 @@
 import type { RpcHandler } from '../../../types';
+/**
+ * Representation of the payload for the JWT used in the checkout process.
+ * This is used to supplement checkout-related information, such as voucher codes,
+ * custom data, preferred collection point, and selected carrier.
+ * This allows pre-filling checkout information and ensures data integrity.
+ */
 interface CheckoutJwtPayload {
+    /**
+     * The voucher code.
+     */
     voucher?: string;
+    /**
+     * Arbitrary custom data associated with the checkout process.  This can be used to store
+     * any additional information relevant to the checkout.
+     */
     customData?: Record<string, unknown>;
+    /**
+     * The preferred collection point.
+     */
     preferredCollectionPoint?: {
+        /**
+         * The collection point Id.
+         */
         id: number;
+        /**
+         * The collection point type.
+         */
         type: string;
     };
+    /**
+     * The selected carrier.
+     */
     carrier?: string;
 }
+/**
+ * Generates a checkout token, which includes a refreshed access token and
+ * a JWT containing checkout information.
+ *
+ * The generated JWT is signed with a secret and includes information from the
+ * provided `jwtPayload`, along with the `basketId` and `campaignKey`.
+ * It is used to pre-fill checkout details and maintain data integrity during
+ * the checkout process.
+ *
+ * @param jwtPayload The payload for the JWT. Provides checkout-related data to embed within the token.
+ * @param context The RPC context.
+ *
+ * @returns An object containing the access token and checkout JWT.
+ * It will return an `ErrorResponse` if no session is found, no access token is present.
+ */
 export declare const getCheckoutToken: RpcHandler<CheckoutJwtPayload | undefined, {
     accessToken: string;
     checkoutJwt: string;

package/dist/rpc/methods/checkout/checkout.mjs

@@ -36,7 +36,7 @@ export const getCheckoutToken = async function getCheckoutToken2(jwtPayload = {}
     carrier,
     basketId: context.basketKey,
     campaignKey
-  }).setIssuedAt(now).setNotBefore(now).setExpirationTime("1h").setIssuer(`${"@scayle/storefront-core"}@${"8.9.0"}`).setProtectedHeader({ alg: "HS256", typ: "JWT" }).sign(secret);
+  }).setIssuedAt(now).setNotBefore(now).setExpirationTime("1h").setIssuer(`${"@scayle/storefront-core"}@${"8.11.0"}`).setProtectedHeader({ alg: "HS256", typ: "JWT" }).sign(secret);
   return {
     accessToken: refreshedAccessToken,
     checkoutJwt

package/dist/rpc/methods/checkout/order.d.ts

@@ -1,5 +1,17 @@
 import { ErrorResponse } from '../../../errors';
 import type { Order } from '../../../types';
+/**
+ * Retrieves an order by its ID.
+ *
+ * @param params The parameters for retrieving an order by its ID.
+ * @param params.orderId The ID of the order to retrieve.
+ * @param context The RPC context.
+ *
+ * @returns The order details if found. It will return an `ErrorResponse` alternatively
+ * if the order ID is invalid, no access token is present,
+ * the order does not belong to the current user, the order is not found,
+ * or an unknown error occurs.
+ */
 export declare const getOrderById: ({ orderId }: {
     orderId: number;
 }, context: import("../../../types").RpcContext) => Promise<ErrorResponse | Order>;

package/dist/rpc/methods/checkout/order.mjs

@@ -21,16 +21,6 @@ export const getOrderById = async function getOrderById2({ orderId }, context) {
       "No access token present"
     );
   }
-  const isOrderInUserOrderlist = context.user?.orderSummary?.find(
-    (order) => order.id === orderId
-  );
-  if (!isOrderInUserOrderlist) {
-    return new ErrorResponse(
-      HttpStatusCode.UNAUTHORIZED,
-      HttpStatusMessage.UNAUTHORIZED,
-      "Order not belonging to current user"
-    );
-  }
   const client = new CustomerAPIClient(context);
   try {
     return await client.getOrder(context.shopId, orderId);

package/dist/rpc/methods/checkout/shopUser.d.ts

@@ -1,8 +1,28 @@
 import { ErrorResponse } from '../../../errors';
 import type { ShopUser, UpdatePasswordParams } from '../../../types';
+/**
+ * Updates the shop user.
+ *
+ * @param payload The payload containing partial user data to update.
+ * @param context The RPC context.
+ *
+ * @returns The updated user. It will return an `ErrorResponse` alternatively
+ * if updating user information fails.
+ */
 export declare const updateShopUser: (payload: Partial<ShopUser>, context: import("../../../types").RpcContext) => Promise<ErrorResponse | {
     user: ShopUser;
 }>;
+/**
+ * Updates the user's password.
+ *
+ * @param payload The payload with old and new password.
+ * @param payload.oldPassword The current password.
+ * @param payload.newPassword The new password.
+ * @param context The RPC context.
+ *
+ * @returns The user object (or undefined if an error occurs and shopUser is undefined).
+ * It will return an `ErrorResponse` if updating the password fails.
+ */
 export declare const updatePassword: ({ oldPassword, newPassword }: UpdatePasswordParams, context: import("../../../types").RpcContext) => Promise<ErrorResponse | {
     user: ShopUser | undefined;
 }>;

package/dist/rpc/methods/checkout/shopUserAddresses.d.ts

@@ -1,3 +1,10 @@
 import type { ShopUserAddress } from '../../../types';
+/**
+ * Retrieves the shop user addresses.
+ *
+ * @param context The RPC context.
+ *
+ * @returns The shop user addresses.
+ */
 declare const getShopUserAddresses: (context: import("../../../types").RpcContext) => Promise<ShopUserAddress[]>;
 export { getShopUserAddresses };

package/dist/rpc/methods/navigationTrees.d.ts

@@ -1,6 +1,33 @@
 import type { NavigationAllEndpointResponseData, NavigationTree } from '@scayle/storefront-api';
 import type { FetchNavigationTreeByIdParams, FetchNavigationTreeByNameParams, FetchNavigationTreesParams } from '../../types';
 import { ErrorResponse } from '../../errors';
+/**
+ * Fetches all navigation trees.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getAll-navigation-trees` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for retrieving all navigation tress.
+ * @param params.params The parameters for fetching navigation trees.
+ * @param context The RPC context.
+ *
+ * @returns The navigation trees data. It will return an `ErrorResponse`
+ * if an error occurs during fetching.
+ */
 export declare const fetchAllNavigationTrees: ({ params }: FetchNavigationTreesParams, { sapiClient: { navigation }, cached }: import("../../types").RpcContext) => Promise<NavigationAllEndpointResponseData>;
+/**
+ * Fetches a navigation tree by its ID.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getById-navigation-trees-${treeId}` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for retrieving a navigation tree by its ID.
+ * @param params.treeId The ID of the navigation tree.
+ * @param params.params The parameters for fetching navigation trees.
+ * @param context The RPC context.
+ *
+ * @returns The navigation tree data. It will return an `ErrorResponse`
+ * if an error occurs during fetching.
+ */
 export declare const fetchNavigationTreeById: ({ treeId, params }: FetchNavigationTreeByIdParams, { sapiClient: { navigation }, cached }: import("../../types").RpcContext) => Promise<NavigationTree>;
 export declare const fetchNavigationTreeByName: ({ treeName, params }: FetchNavigationTreeByNameParams, { sapiClient: { navigation }, cached }: import("../../types").RpcContext) => Promise<ErrorResponse | NavigationTree>;

package/dist/rpc/methods/oauth/idp.d.ts

@@ -1,10 +1,34 @@
 import { ErrorResponse } from '../../../errors';
 import type { RpcContext } from '../../../types';
+/**
+ * Retrieves external IDP redirect URLs.
+ *
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/authentication#overview
+ *
+ * @param params The parameters for retrieving the external IDP redirect.
+ * @param params.queryParams Optional query parameters to include in the redirect URLs.
+ * @param context The RPC context.
+ *
+ * @returns A record mapping IDP keys to their corresponding redirect URLs,
+ * or an ErrorResponse if an error occurs. It will return an `ErrorResponse`
+ * if JWT signing fails or another unexpected error occurs.
+ */
 export declare const getExternalIdpRedirect: ({ queryParams }: {
     queryParams?: Record<string, string>;
 }, context: RpcContext) => Promise<ErrorResponse | {
     [k: string]: string;
 }>;
+/**
+ * Handles the IDP login callback.
+ *
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/authentication#overview
+ *
+ * @param payload The payload containing the authorization code.
+ * @param payload.code The authorization code.
+ * @param context The RPC context.
+ *
+ * @returns A success message, or an `ErrorResponse` an error during login occurs.
+ */
 export declare const handleIDPLoginCallback: (payload: {
     code: string;
 }, context: RpcContext) => Promise<ErrorResponse | {

package/dist/rpc/methods/products.d.ts

@@ -1,12 +1,17 @@
 import type { FetchFiltersParams, FetchFiltersResponse, FetchProductParams, FetchProductsByCategoryParams, FetchProductsByCategoryResponse, FetchProductsByIdsParams, FetchProductsByReferenceKeysParams, FetchProductsCountParams, FetchProductsCountResponse, Product, RpcContext, RpcHandler } from '../../types';
 /**
- * For functions which accept either a category path or category ID,
- * this function can resolve the ID which is necessary for the calling
- * the Storefront APIs.
- * @param context
- * @param params
- * @returns A object with `category` and `categoryId` properties.
- *  If no `category` was provided in the params, it will be undefined or '/'
+ * Resolves the category ID from provided parameters.
+ * This function handles cases where either a category path or ID is provided.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getById-navigation-trees-${treeId}` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param context The RPC context.
+ * @param params The parameters for resolving a category ID from provides params.
+ * @param params.category The category path.
+ * @param params.categoryId The category ID.
+ *
+ * @returns A Promise resolving to an object with `category` (path) and `categoryId` properties.
  */
 export declare function resolveCategoryIdFromParams(context: RpcContext, params: {
     category?: string;
@@ -18,15 +23,153 @@ export declare function resolveCategoryIdFromParams(context: RpcContext, params:
     category: string | undefined;
     categoryId: number | undefined;
 }>;
+/**
+ * Retrieves a product by its ID.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getById-product-${options.id}` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param options The options for retrieving a single product by its ID.
+ * @param options.id The ID of the product.
+ * @param options.with Fields to include in the response.
+ * @param options.pricePromotionKey Price promotion key.
+ * @param options.includeSellableForFree Whether to include sellable for free products.
+ * @param context The RPC context.
+ *
+ * @returns A Promise resolving to the product data. It will return a
+ * `ErrorResponse` alternatively If the product retrieval fails.
+ */
 export declare const getProductById: RpcHandler<FetchProductParams, Product>;
+/**
+ * Retrieves multiple products by their IDs.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getByIds-products` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param options The options for retrieving multiple products by their IDs.
+ * @param options.ids An array of product IDs.
+ * @param options.with Fields to include in the response.
+ * @param options.pricePromotionKey Price promotion key.
+ * @param context The RPC context.
+ *
+ * @returns A Promise resolving to an array of product data.
+ * It will return an `ErrorResponse` if the product retrieval fails.
+ */
 export declare const getProductsByIds: RpcHandler<FetchProductsByIdsParams, Product[]>;
+/**
+ * Retrieves products by their reference keys.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getByReferenceKeys-products` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param options The options for retrieving products.
+ * @param options.referenceKeys An array of product reference keys.
+ * @param options.with The fields to include in the response.
+ * @param options.pricePromotionKey The price promotion key.
+ * @param context The RPC context.
+ *
+ * @returns A Promise that resolves with an array of products.
+ * It will return an `ErrorResponse` if the Storefront API request fails.
+ */
 export declare const getProductsByReferenceKeys: RpcHandler<FetchProductsByReferenceKeysParams, Product[]>;
+/**
+ * Retrieves the count of products matching the provided parameters.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `products-query` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for retrieving the product count.
+ * @param params.categoryId ID of the category.
+ * @param params.category Path of the category.
+ * @param params.includedFilters Filters to include.
+ * @param params.where Search criteria.
+ * @param params.where.minPrice Minimum price.
+ * @param params.where.maxPrice Maximum price.
+ * @param params.where.term Search term.
+ * @param params.where.attributes Attributes for filtering.
+ * @param params.where.whitelistAttributes Whitelisted attributes for filtering.
+ * @param params.where.disableFuzziness Whether to disable fuzzy search.
+ * @param params.includeSoldOut Whether to include sold out products.
+ * @param params.includeSellableForFree Whether to include products sellable for free.
+ * @param params.orFiltersOperator Whether to use the OR operator for filters.
+ * @param context The RPC context.
+ *
+ * @returns A Promise that resolves with the product count.
+ */
 export declare const getProductsCount: RpcHandler<FetchProductsCountParams, FetchProductsCountResponse>;
+/**
+ * Fetches all filters for a given category.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `filters-for-category-${category.id}` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for fetching filters for a category.
+ * @param params.includedFilters An array of filter slugs to include.
+ * @param params.category Category data.
+ * @param context The RPC context.
+ *
+ * @returns A Promise resolving to an array of filter slugs.
+ *
+ * @throws Will throw an error if fetching filters fails.
+ */
 export declare const fetchAllFiltersForCategory: RpcHandler<{
     includedFilters?: string[];
     category: {
         id?: number;
     };
 }, string[]>;
+/**
+ * Retrieves filters and product count for a given category.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `get-filters-${categoryId}` and `products-query-category-${categoryId}` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for fetching filters.
+ * @param params.includedFilters An array of included filters.
+ * @param params.where The where clause for filtering.
+ * @param params.where.minPrice Minimum price.
+ * @param params.where.maxPrice Maximum price.
+ * @param params.where.term Search term.
+ * @param params.where.attributes Attributes for filtering.
+ * @param params.where.whitelistAttributes Whitelisted attributes.
+ * @param params.where.disableFuzziness Whether to disable fuzziness.
+ * @param params.includeSoldOut Whether to include sold out products.
+ * @param params.includeSellableForFree Whether to include products sellable for free.
+ * @param params.orFiltersOperator The operator for OR filters.
+ * @param context The RPC context.
+ *
+ * @returns An object containing the filters and unfiltered count.
+ */
 export declare const getFilters: RpcHandler<FetchFiltersParams, FetchFiltersResponse>;
+/**
+ * Retrieves products by category.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `products-query-category-${categoryId}` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for fetching products.
+ * @param params.includedFilters An array of included filters.
+ * @param params.cache Cache options.
+ * @param params.cache.ttl Time to live for the cache.
+ * @param params.cache.cacheKeyPrefix Cache key prefix.
+ * @param params.with The 'with' parameter for including additional data.
+ * @param params.perPage Number of products per page.
+ * @param params.page Page number.
+ * @param params.where The where clause for filtering.
+ * @param params.where.minPrice Minimum price.
+ * @param params.where.maxPrice Maximum price.
+ * @param params.where.term Search term.
+ * @param params.where.attributes Attributes for filtering.
+ * @param params.where.whitelistAttributes Whitelisted attributes.
+ * @param params.where.disableFuzziness Whether to disable fuzziness.
+ * @param params.sort Sorting criteria.
+ * @param params.pricePromotionKey Price promotion key.
+ * @param params.includeSellableForFree Whether to include products sellable for free.
+ * @param params.includeSoldOut Whether to include sold out products.
+ * @param params.orFiltersOperator The operator for OR filters.
+ * @param params.trackSearchAnalyticsEvent Whether to track search analytics event.
+ * @param context The RPC context.
+ *
+ * @returns An object containing the products and pagination information.
+ */
 export declare const getProductsByCategory: RpcHandler<FetchProductsByCategoryParams, FetchProductsByCategoryResponse>;

package/dist/rpc/methods/products.mjs

@@ -24,9 +24,7 @@ export async function resolveCategoryIdFromParams(context, params) {
     category = params.category;
     const result = await context.cached(
       context.sapiClient.categories.getByPath,
-      {
-        cacheKeyPrefix: `getByPath-categories-${category}`
-      }
+      { cacheKeyPrefix: `getByPath-categories-${category}` }
     )(splitAndRemoveEmpty(category));
     categoryId = result.id;
   } else {

package/dist/rpc/methods/promotion.d.ts

@@ -1,4 +1,46 @@
-import type { PromotionsParams, PromotionsResponseData } from '../../types';
-export declare const getPromotions: (params: Omit<PromotionsParams, "ids"> | undefined, context: import("../../types").RpcContext) => Promise<Response | PromotionsResponseData>;
-export declare const getCurrentPromotions: (params: Omit<PromotionsParams, "ids" | "activeAt"> | undefined, context: import("../../types").RpcContext) => Promise<Response | PromotionsResponseData>;
-export declare const getPromotionsByIds: (ids: string[], context: import("../../types").RpcContext) => Promise<Response | PromotionsResponseData>;
+import type { PromotionsParams, PromotionsResponseData, RpcContext } from '../../types';
+/**
+ * Retrieves promotions based on provided parameters.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getPromotions` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for retrieving promotions.
+ * @param params.pagination Pagination settings.
+ * @param params.pagination.page Page number.
+ * @param params.pagination.perPage Number of items per page.
+ * @param context The RPC context.
+ *
+ * @returns A Promise that resolves with the promotion data.
+ * It will return an `ErrorResponse` if the The Storefront API request fails.
+ */
+export declare const getPromotions: (params: Omit<PromotionsParams, "ids"> | undefined, context: RpcContext) => Promise<Response | PromotionsResponseData>;
+/**
+ * Retrieves currently active promotions.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getPromotions` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for retrieving promotions.
+ * @param params.pagination Pagination settings.
+ * @param params.pagination.page Page number.
+ * @param params.pagination.perPage Number of items per page.
+ * @param context The RPC context.
+ *
+ * @returns A Promise that resolves with the current promotion data.
+ * It will return an `ErrorResponse` if the The Storefront API request fails.
+ */
+export declare const getCurrentPromotions: (params: Omit<PromotionsParams, "ids" | "activeAt"> | undefined, context: RpcContext) => Promise<Response | PromotionsResponseData>;
+/**
+ * Retrieves promotions by their IDs.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getByIds-promotions` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param ids An array of promotion IDs.
+ * @param context The RPC context.
+ *
+ * @returns A Promise that resolves with the promotion data.
+ * It will return an `ErrorResponse` if the The Storefront API request fails.
+ */
+export declare const getPromotionsByIds: (ids: string[], context: RpcContext) => Promise<Response | PromotionsResponseData>;

package/dist/rpc/methods/search.d.ts

@@ -1,25 +1,30 @@
 import type { SearchEntity, SearchV2ResolveEndpointParameters, SearchV2SuggestionsEndpointParameters, SearchV2SuggestionsEndpointResponseData } from '../../types/sapi/search';
+import type { RpcContext } from '../../types';
 /**
  * Fetches search suggestions for a given term.
  *
- * @param option - The parameters for the request.
- * @param option.term - The term to search for.
- * @param option.with - An object describing which data the returned suggestions should contain.
- * @param option.categoryId - The category ID to search within.
- * @param context - The rpc context associated with the request.
+ * @param option The parameters for the request.
+ * @param option.term The term to search for.
+ * @param option.with An object describing which data the returned suggestions should contain.
+ * @param option.categoryId The category ID to search within.
+ * @param context The RPC context.
  *
  * @returns A promise that resolves to a list of search suggestions.
+ * It will return an `ErrorResponse` if the request fails.
  */
-export declare const getSearchSuggestions: ({ term, with: _with, categoryId }: SearchV2SuggestionsEndpointParameters, { sapiClient, withParams }: import("../../types").RpcContext) => Promise<Response | SearchV2SuggestionsEndpointResponseData>;
+export declare const getSearchSuggestions: ({ term, with: _with, categoryId }: SearchV2SuggestionsEndpointParameters, context: RpcContext) => Promise<Response | SearchV2SuggestionsEndpointResponseData>;
 /**
  * Resolves a search query and returns the resolved entity.
  *
- * @param option - The parameters for the search query.
- * @param option.term - The search query to resolve.
- * @param option.with - An object describing which data the returned result should contain.
- * @param option.categoryId - The category ID for which the search should be performed.
- * @param context - The rpc context associated with the request.
+ * This function uses the Storefront cache (`cached()`) with a `resolve-${term}` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param option The parameters for the search query.
+ * @param option.term The search query to resolve.
+ * @param option.with An object describing which data the returned result should contain.
+ * @param option.categoryId The category ID for which the search should be performed.
+ * @param context The RPC context.
  *
  * @returns A promise that resolves to the resolved entity or null if no entity is found.
  */
-export declare const resolveSearch: ({ term, with: _with, categoryId }: SearchV2ResolveEndpointParameters, { cached, sapiClient, withParams }: import("../../types").RpcContext) => Promise<SearchEntity | null>;
+export declare const resolveSearch: ({ term, with: _with, categoryId }: SearchV2ResolveEndpointParameters, context: RpcContext) => Promise<SearchEntity | null>;

package/dist/rpc/methods/search.mjs

@@ -1,5 +1,6 @@
 import { mapSAPIFetchErrorToResponse } from "../../utils/sapi.mjs";
-export const getSearchSuggestions = async function getSearchSuggestions2({ term, with: _with, categoryId }, { sapiClient, withParams }) {
+export const getSearchSuggestions = async function getSearchSuggestions2({ term, with: _with, categoryId }, context) {
+  const { sapiClient, withParams } = context;
   return await mapSAPIFetchErrorToResponse(sapiClient.searchv2.suggestions)(
     term,
     {
@@ -8,7 +9,8 @@ export const getSearchSuggestions = async function getSearchSuggestions2({ term,
     }
   );
 };
-export const resolveSearch = async function resolveSearch2({ term, with: _with, categoryId }, { cached, sapiClient, withParams }) {
+export const resolveSearch = async function resolveSearch2({ term, with: _with, categoryId }, context) {
+  const { cached, sapiClient, withParams } = context;
   const resolvedEntity = await cached(sapiClient.searchv2.resolve, {
     cacheKeyPrefix: `resolve-${term}`
   })(term, {

package/dist/rpc/methods/session.d.ts

@@ -1,20 +1,82 @@
 import type { Optional } from 'utility-types';
 import type { GuestRequest, LoginRequest, Oauth, RegisterRequest, RpcContext, RpcContextWithSession, ShopUser, UpdatePasswordByHashRequest } from '../../types';
 import { ErrorResponse } from '../../errors';
+/**
+ * Handles the post-login logic, including fetching user data, updating tokens,
+ * merging baskets and wishlists, and creating a user-bound session.
+ *
+ * @param context The RPC context with session information.
+ * @param tokens The OAuth tokens.
+ *
+ * @returns The result of the post login operation. It will return
+ * an `ErrorResponse` if fetching the user or merging baskets/wishlists fails.
+ */
 export declare function postLogin(context: RpcContextWithSession, tokens: Oauth): Promise<(ShopUser & ErrorResponse) | undefined>;
+/**
+ * Handles OAuth login requests.
+ *
+ * @param login The login request data. Includes `email` and `password` keys.
+ * @param context The RPC context.
+ *
+ * @returns A Response object indicating the login status. It will return
+ * an `ErrorResponse` if login fails.
+ */
 export declare const oauthLogin: (login: Optional<LoginRequest, "shop_id">, context: RpcContext) => Promise<Response>;
+/**
+ * Handles OAuth user registration requests.
+ *
+ * @param register The registration request data.
+ * @param context The RPC context.
+ *
+ * @returns A Response object indicating the registration status. It will return
+ * an `ErrorResponse` if registration fails.
+ */
 export declare const oauthRegister: (register: Optional<RegisterRequest, "shop_id">, context: RpcContext) => Promise<Response>;
+/**
+ * Handles OAuth guest login requests.
+ *
+ * @param guest The guest login request data.
+ * @param context The RPC context.
+ *
+ * @returns A Response object indicating the login status. It will return
+ * an `ErrorResponse` if guest login fails.
+ */
 export declare const oauthGuestLogin: (guest: Optional<GuestRequest, "shop_id">, context: RpcContext) => Promise<Response>;
+/**
+ * Refreshes the access token using the refresh token.
+ *
+ * @param context The RPC context.
+ *
+ * @returns An object indicating the success status of the refresh operation.
+ *  It will return an `ErrorResponse` if refreshing the token fails.
+ */
 export declare const refreshAccessToken: (context: RpcContext) => Promise<Response | {
     success: true;
 } | {
     success: false;
 }>;
+/**
+ * Revokes the current access token and destroys the session.
+ *
+ * @param context The RPC context.
+ *
+ * @returns An object indicating the result of the revocation.
+ * It will return an `ErrorResponse` if revoking the token fails.
+ */
 export declare const oauthRevokeToken: (context: RpcContext) => Promise<Response | {
     result: true;
 } | {
     result: false;
 }>;
+/**
+ * Sends a password reset email to the specified email address.
+ *
+ * @param email The email address for password reset. Includes email key.
+ * @param context The RPC context.
+ *
+ * @returns An object indicating the success status of the operation.
+ * It will return an `ErrorResponse` if sending the password reset email fails.
+ */
 export declare const oauthForgetPassword: ({ email }: {
     email: string;
 }, context: RpcContext) => Promise<Response | {
@@ -22,4 +84,13 @@ export declare const oauthForgetPassword: ({ email }: {
 } | {
     success: false;
 }>;
+/**
+ * Updates the password using a password hash.
+ *
+ * @param passwordHash The password hash data.
+ * @param context The RPC context.
+ *
+ * @returns A Response object indicating the status of the password update.
+ * It will return an `ErrorResponse` if updating the password fails.
+ */
 export declare const updatePasswordByHash: (passwordHash: Optional<UpdatePasswordByHashRequest, "shop_id">, context: RpcContext) => Promise<Response>;