@djust-b2b/djust-front-sdk 3.0.0-beta.2 → 3.0.0-beta.20

package/dist/services/attributes/definitions.d.ts

@@ -0,0 +1,28 @@
+import { Attribute } from "../../interfaces/models/attribute";
+import { PageableObject, PageableParameters, Order } from "../../interfaces/models/common";
+/**
+ * Request parameters type definitions
+ */
+export interface GetAttributesParameters {
+    searchCriteria?: string;
+    pageable?: PageableParameters;
+    searchable?: boolean;
+    sortable?: boolean;
+}
+/**
+ * Response type definitions
+ */
+export interface GetAttributesResponse {
+    content: Attribute[];
+    empty: boolean;
+    first: boolean;
+    last: boolean;
+    number: number;
+    numberOfElements: number;
+    pageable: PageableObject;
+    size: number;
+    sort: Order[];
+    totalElements: number;
+    totalPages: number;
+}
+//# sourceMappingURL=definitions.d.ts.map

package/dist/services/attributes/definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../../src/services/attributes/definitions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAC9D,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,KAAK,EACN,MAAM,gCAAgC,CAAC;AAExC;;GAEG;AAEH,MAAM,WAAW,uBAAuB;IACtC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAC9B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;GAEG;AAEH,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,cAAc,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,KAAK,EAAE,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB"}

package/dist/services/attributes/endpoints.d.ts

@@ -0,0 +1,12 @@
+/**
+ * DJUST SDK Attributes Service - Endpoints
+ * API endpoint constants for attributes operations.
+ *
+ * @module services/attributes/endpoints
+ * @since 2.17.0
+ */
+export declare const AttributesEndpoints: {
+    readonly ATTRIBUTES: "/v1/shop/attributes";
+};
+export type AttributesEndpoint = (typeof AttributesEndpoints)[keyof typeof AttributesEndpoints];
+//# sourceMappingURL=endpoints.d.ts.map

package/dist/services/attributes/endpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoints.d.ts","sourceRoot":"","sources":["../../../src/services/attributes/endpoints.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,mBAAmB;;CAEtB,CAAC;AAEX,MAAM,MAAM,kBAAkB,GAC5B,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/services/attributes/index.d.ts

@@ -0,0 +1,33 @@
+import { GetAttributesParameters, GetAttributesResponse } from "./definitions";
+/**
+ * 🛒 Retrieves all attributes.
+ *
+ * This function allows fetching the list of attributes.
+ *
+ * 🛠 **Endpoint**: `GET /v1/shop/attributes [listAttribute]`
+ *
+ * | Parameter        | Type                 | Required   | Description                                                |
+ * |------------------|----------------------|------------|------------------------------------------------------------|                |
+ * | `searchCriteria` | `string`             | ❌         | The search term.                                 |
+ * | `searchable`     | `boolean`            | ❌         | If appears in search response.                                 |
+ * | `sortable`       | `boolean`            | ❌         | If is sortable.                                 |
+ * | `pageable`       | `object`             | ❌         | The pagination parameters.                , `BUYING_LIST`).                             |
+ *
+ * 📤 **Returns**:
+ * A `Promise` resolving to a `GetAttributesResponse` object, containing the list of attributes and pagination information.
+ *
+ * 🛠 **Example usage**:
+ * ```ts
+ * const attributes = await getAttributes({ pageable: { page: 1, size: 10 } });
+ * ```
+ *
+ * @param {GetAttributesParameters} params - The parameters for retrieving the attributes, including:
+ *   - `searchCriteria` - The search term.
+ *   - `searchable` - The boolean if attributes appears in search response.
+ *   - `sortable` - The boolean if can sort by this attribute.
+ *   - `pageable` - The pagination parameters.
+ *
+ * @returns {Promise<GetAttributesResponse>} - An object containing the list of attributes and pagination information.
+ */
+export declare function getAttributes({ searchCriteria, searchable, sortable, pageable, }: GetAttributesParameters): Promise<GetAttributesResponse>;
+//# sourceMappingURL=index.d.ts.map

package/dist/services/attributes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/attributes/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,aAAa,CAAC,EAClC,cAAc,EACd,UAAU,EACV,QAAQ,EACR,QAAQ,GACT,EAAE,uBAAuB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAe1D"}

package/dist/services/attributes/module.d.ts

@@ -0,0 +1,11 @@
+/**
+ * DJUST SDK Attributes Module
+ * Re-exports all attributes-related types and service.
+ *
+ * @module services/attributes
+ * @since 2.17.0
+ */
+export type { GetAttributesParams, Attribute, AttributeValue, GetAttributesResponse, } from "./types";
+export { AttributesEndpoints, type AttributesEndpoint } from "./endpoints";
+export { AttributesService } from "./attributes.service";
+//# sourceMappingURL=module.d.ts.map

package/dist/services/attributes/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../src/services/attributes/module.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,YAAY,EACV,mBAAmB,EACnB,SAAS,EACT,cAAc,EACd,qBAAqB,GACtB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,mBAAmB,EAAE,KAAK,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAC3E,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/services/attributes/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * DJUST SDK Attributes Service - Types
+ * Type definitions for attributes operations.
+ *
+ * @module services/attributes/types
+ * @since 2.17.0
+ */
+import type { Pageable, PaginatedResponse } from "../types";
+export interface GetAttributesParams {
+    searchCriteria?: string;
+    searchable?: boolean;
+    sortable?: boolean;
+    pageable?: Pageable;
+}
+export interface Attribute {
+    id: string;
+    externalId?: string;
+    name: string;
+    code: string;
+    type: string;
+    searchable: boolean;
+    sortable: boolean;
+    filterable: boolean;
+    values?: AttributeValue[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface AttributeValue {
+    id: string;
+    value: string;
+    label?: string;
+}
+export interface GetAttributesResponse extends PaginatedResponse<Attribute> {
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/services/attributes/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/services/attributes/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAM5D,MAAM,WAAW,mBAAmB;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAMD,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,cAAc,EAAE,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAGD,MAAM,WAAW,qBAAsB,SAAQ,iBAAiB,CAAC,SAAS,CAAC;CAAG"}

package/dist/services/auth/__mocks__/auth.mocks.d.ts

@@ -0,0 +1,249 @@
+/**
+ * Mocks centralisés pour les tests du module auth
+ */
+export declare const mockTokens: {
+    validToken: string;
+    invalidToken: string;
+    refreshToken: string;
+    resetPasswordToken: string;
+};
+export declare const mockUsers: {
+    validUser: {
+        username: string;
+        password: string;
+    };
+    invalidUser: {
+        username: string;
+        password: string;
+    };
+};
+export declare const mockAuthResponses: {
+    loginSuccess: {
+        token: {
+            accessToken: string;
+            expireAt: number;
+            refreshToken: string;
+        };
+        user: {
+            id: string;
+        };
+    };
+    refreshTokenSuccess: {
+        token: {
+            accessToken: string;
+            expireAt: number;
+            refreshToken: string;
+        };
+        user: {
+            id: string;
+        };
+    };
+};
+export declare const mockParameters: {
+    isTokenValid: {
+        valid: {
+            token: string;
+        };
+        invalid: {
+            token: string;
+        };
+    };
+    refreshToken: {
+        valid: {
+            refreshToken: string;
+        };
+    };
+    resetPassword: {
+        valid: {
+            newPassword: string;
+            resetPasswordToken: string;
+        };
+    };
+    sendResetPasswordEmail: {
+        valid: {
+            email: string;
+        };
+        invalid: {
+            email: string;
+        };
+    };
+    login: {
+        valid: {
+            username: string;
+            password: string;
+        };
+        withUserFalse: {
+            username: string;
+            password: string;
+            withUser: boolean;
+        };
+        invalid: {
+            username: string;
+            password: string;
+        };
+    };
+    getStore: {
+        valid: {
+            storeId: string;
+        };
+    };
+};
+export declare const mockResponses: {
+    isTokenValid: {
+        success: {
+            data: boolean;
+            headers: Headers;
+            status: number;
+        };
+        failure: {
+            data: boolean;
+            headers: Headers;
+            status: number;
+        };
+    };
+    refreshToken: {
+        success: {
+            data: {
+                token: {
+                    accessToken: string;
+                    expireAt: number;
+                    refreshToken: string;
+                };
+                user: {
+                    id: string;
+                };
+            };
+            headers: Headers;
+            status: number;
+        };
+    };
+    resetPassword: {
+        success: {
+            data: undefined;
+            headers: Headers;
+            status: number;
+        };
+    };
+    sendResetPasswordEmail: {
+        success: {
+            data: undefined;
+            headers: Headers;
+            status: number;
+        };
+    };
+    login: {
+        success: {
+            data: {
+                token: {
+                    accessToken: string;
+                    expireAt: number;
+                    refreshToken: string;
+                };
+                user: {
+                    id: string;
+                };
+            };
+            headers: Headers;
+            status: number;
+        };
+        withUserFalse: {
+            data: {
+                token: {
+                    accessToken: string;
+                    expireAt: number;
+                    refreshToken: string;
+                };
+                user: {
+                    id: string;
+                };
+            };
+            headers: Headers;
+            status: number;
+        };
+    };
+    logout: {
+        success: {
+            data: undefined;
+            headers: Headers;
+            status: number;
+        };
+    };
+    getSettings: {
+        success: {
+            data: {
+                manualAccountCheck: boolean;
+            };
+            headers: Headers;
+            status: number;
+        };
+    };
+    getStore: {
+        success: {
+            data: {
+                active: boolean;
+                customFieldValues: {
+                    customField: {
+                        externalId: string;
+                        externalSource: string;
+                        faceted: boolean;
+                        id: string;
+                        indexable: boolean;
+                        mandatory: boolean;
+                        name: {
+                            fr: string;
+                            en: string;
+                        };
+                        role: string;
+                        sealedTarget: string;
+                        searchable: boolean;
+                        sortable: boolean;
+                        status: string;
+                    };
+                    value: {
+                        fr: string;
+                        en: string;
+                    };
+                }[];
+                description: string;
+                externalId: string;
+                id: string;
+                name: string;
+                storeLocales: {
+                    active: boolean;
+                    code: string;
+                    id: string;
+                    label: string;
+                    main: boolean;
+                }[];
+            };
+            headers: Headers;
+            status: number;
+        };
+    };
+};
+export declare const mockErrors: {
+    networkError: Error;
+    unauthorized: Error;
+    badRequest: Error;
+    notFound: Error;
+    serverError: Error;
+};
+export declare const mockHttpErrors: {
+    400: {
+        status: number;
+        message: string;
+    };
+    401: {
+        status: number;
+        message: string;
+    };
+    404: {
+        status: number;
+        message: string;
+    };
+    500: {
+        status: number;
+        message: string;
+    };
+};
+//# sourceMappingURL=auth.mocks.d.ts.map

package/dist/services/auth/__mocks__/auth.mocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.mocks.d.ts","sourceRoot":"","sources":["../../../../src/services/auth/__mocks__/auth.mocks.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,eAAO,MAAM,UAAU;;;;;CAOtB,CAAC;AAGF,eAAO,MAAM,SAAS;;;;;;;;;CASrB,CAAC;AAGF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;CAqB7B,CAAC;AAGF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoC1B,CAAC;AAYF,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8GzB,CAAC;AAGF,eAAO,MAAM,UAAU;;;;;;CAMtB,CAAC;AAGF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;CAK1B,CAAC"}

package/dist/services/auth/auth.service.d.ts

@@ -0,0 +1,286 @@
+/**
+ * # Auth Service
+ *
+ * This module provides all functionalities related to user authentication and authorization.
+ *
+ * ## Features:
+ * - Validate tokens
+ * - Refresh tokens
+ * - Reset user passwords
+ * - Manage user login and logout
+ * - Send password reset emails
+ * - Retrieve shop settings and store information
+ *
+ * Each method is described with its input parameters, output responses, and example usages.
+ *
+ * @module services/auth
+ * @since 2.17.0
+ */
+import { BaseService } from "../base.service";
+import type { RequestContext } from "../../client/transport";
+import type { IsTokenValidParams, RefreshTokenParams, ResetPasswordParams, SendResetPasswordEmailParams, LoginParams, GetStoreParams, RefreshTokenResponse, LoginResponse, SettingsResponse, Store } from "./types";
+/**
+ * Service for authentication and authorization operations.
+ *
+ * Provides methods for:
+ * - 🔐 User login/logout
+ * - 🔄 Token validation and refresh
+ * - 🔑 Password reset
+ * - ⚙️ Shop settings and store information
+ *
+ * @example
+ * ```typescript
+ * import { createDjustClient } from '@djust-b2b/djust-front-sdk';
+ *
+ * const client = createDjustClient({
+ *   baseUrl: 'https://api.djust.io',
+ *   clientId: 'your-client-id',
+ *   apiKey: 'your-api-key',
+ * });
+ *
+ * // Login
+ * const { token, user } = await client.auth.login({
+ *   username: 'user@example.com',
+ *   password: 'password123',
+ * });
+ *
+ * // Validate token
+ * const isValid = await client.auth.isTokenValid({ token: token.accessToken });
+ * ```
+ */
+export declare class AuthService extends BaseService {
+    readonly serviceName = "auth";
+    /**
+     * 🔐 Validates if a token is still active and unexpired.
+     *
+     * This method checks whether the provided token is valid, ensuring it has not expired or been invalidated.
+     *
+     * 🛠 **Endpoint**: `GET /auth/is-token-valid [TOK-200]`
+     *
+     * | Parameter | Type     | Required | Description                         |
+     * |-----------|----------|----------|-------------------------------------|
+     * | `token`   | `string` | ✅       | The token to validate.              |
+     *
+     * 📤 **Returns**:
+     * A `Promise<boolean>` resolving to `true` if the token is valid and active, or `false` otherwise.
+     *
+     * @example
+     * ```typescript
+     * const isValid = await client.auth.isTokenValid({
+     *   token: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+     * });
+     * console.log(isValid); // true
+     * ```
+     *
+     * @param params - The parameters for validating the token.
+     * @param context - Optional request context for SSR.
+     * @throws {ValidationError} If the required `token` parameter is missing.
+     * @returns A promise that resolves to a boolean indicating whether the token is valid.
+     */
+    isTokenValid(params: IsTokenValidParams, context?: RequestContext): Promise<boolean>;
+    /**
+     * 🔄 Requests a new access token using a refresh token.
+     *
+     * This method allows you to obtain a new access token by providing a valid refresh token.
+     *
+     * 🛠 **Endpoint**: `POST /auth/refresh-token [AUTH-102]`
+     *
+     * | Parameter       | Type     | Required | Description                                      |
+     * |-----------------|----------|----------|--------------------------------------------------|
+     * | `refreshToken`  | `string` | ✅       | The refresh token used to request a new access token. |
+     *
+     * 📤 **Returns**:
+     * A `Promise<RefreshTokenResponse>` containing the new access token, its expiry time, and a refreshed token.
+     *
+     * @example
+     * ```typescript
+     * const response = await client.auth.refreshToken({
+     *   refreshToken: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+     * });
+     * console.log(response.token.accessToken);
+     * console.log(response.token.expiresAt);
+     * ```
+     *
+     * @param params - The parameters for requesting a new token.
+     * @param context - Optional request context for SSR.
+     * @throws {ValidationError} If the required `refreshToken` parameter is missing.
+     * @returns A promise that resolves to the response containing the new token and user details.
+     */
+    refreshToken(params: RefreshTokenParams, context?: RequestContext): Promise<RefreshTokenResponse>;
+    /**
+     * 🔑 Resets the password of a user.
+     *
+     * This method allows a user to reset their password by providing a new password along with a valid reset token.
+     *
+     * 🛠 **Endpoint**: `POST /auth/reset-password [PWD-102]`
+     *
+     * | Parameter             | Type     | Required | Description                                                  |
+     * |-----------------------|----------|----------|--------------------------------------------------------------|
+     * | `newPassword`         | `string` | ✅       | The new password to set for the user.                        |
+     * | `resetPasswordToken`  | `string` | ✅       | The token required to authenticate the password reset process. |
+     *
+     * 📤 **Returns**:
+     * A `Promise<void>` that resolves when the password is successfully reset.
+     *
+     * @example
+     * ```typescript
+     * await client.auth.resetPassword({
+     *   newPassword: "mySecurePassword2025!",
+     *   resetPasswordToken: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+     * });
+     * ```
+     *
+     * @param params - The parameters required for resetting the password.
+     * @param context - Optional request context for SSR.
+     * @throws {ValidationError} If the required parameters `newPassword` or `resetPasswordToken` are missing.
+     */
+    resetPassword(params: ResetPasswordParams, context?: RequestContext): Promise<void>;
+    /**
+     * 📧 Sends a reset password email to a user.
+     *
+     * This method sends an email containing a reset password link to the specified email address.
+     *
+     * 🛠 **Endpoint**: `POST /auth/send-reset-password-email [PWD-101]`
+     *
+     * | Parameter     | Type     | Required | Description                                        |
+     * |---------------|----------|----------|----------------------------------------------------|
+     * | `email`       | `string` | ✅       | The email address to which the reset link will be sent. |
+     * | `redirectUrl` | `string` | ❌       | Optional URL to redirect after password reset.     |
+     *
+     * 📤 **Returns**:
+     * A `Promise<void>` that resolves when the reset password email is successfully sent.
+     *
+     * @example
+     * ```typescript
+     * await client.auth.sendResetPasswordEmail({
+     *   email: "user@example.com",
+     *   redirectUrl: "https://myapp.com/reset-password",
+     * });
+     * ```
+     *
+     * @param params - The parameters required to send the reset password email.
+     * @param context - Optional request context for SSR.
+     * @throws {ValidationError} If the required parameter `email` is missing.
+     */
+    sendResetPasswordEmail(params: SendResetPasswordEmailParams, context?: RequestContext): Promise<void>;
+    /**
+     * 🔐 Logs in a user.
+     *
+     * This method allows a user to log in by providing their username and password,
+     * and returns their login information, including an access token and user details.
+     *
+     * 🛠 **Endpoint**: `POST /auth/token?withUser=true [AUTH-101]`
+     *
+     * | Parameter   | Type      | Required | Description                          |
+     * |-------------|-----------|----------|--------------------------------------|
+     * | `username`  | `string`  | ✅       | The username of the user to log in.  |
+     * | `password`  | `string`  | ✅       | The password of the user to log in.  |
+     * | `withUser`  | `boolean` | ❌       | Whether to include user details in the response. Default: `true` |
+     *
+     * 📤 **Returns**:
+     * A `Promise<LoginResponse>` that resolves to the user's login information, including:
+     * - `token` (object): Contains the `accessToken`, `refreshToken`, and `expireAt` timestamp.
+     * - `user` (object): Contains the user's `id` and details (if `withUser` is true).
+     *
+     * @example
+     * ```typescript
+     * const loginResponse = await client.auth.login({
+     *   username: "user@example.com",
+     *   password: "password123",
+     * });
+     *
+     * console.log(loginResponse.token.accessToken);
+     * console.log(loginResponse.user.id);
+     * ```
+     *
+     * @param params - The parameters required for logging in the user.
+     * @param context - Optional request context for SSR.
+     * @throws {ValidationError} If the required parameters `username` or `password` are missing.
+     * @throws {AuthError} If credentials are invalid.
+     * @returns Resolves to an object containing the user's login information.
+     */
+    login(params: LoginParams, context?: RequestContext): Promise<LoginResponse>;
+    /**
+     * 🚪 Logs out the user.
+     *
+     * This method logs out the user by revoking their authentication token.
+     *
+     * 🛠 **Endpoint**: `POST /auth/revoke-token [AUTH-103]`
+     *
+     * | Parameter | Type | Required | Description |
+     * |-----------|------|----------|-------------|
+     * | *(none)*  | -    | -        | This method does not require any parameters. |
+     *
+     * 📤 **Returns**:
+     * A `Promise<void>` that resolves when the user is successfully logged out.
+     *
+     * @example
+     * ```typescript
+     * await client.auth.logout();
+     * // User is now logged out, token is revoked
+     * ```
+     *
+     * @param context - Optional request context for SSR.
+     * @throws {NetworkError} If there is an issue with the logout process.
+     */
+    logout(context?: RequestContext): Promise<void>;
+    /**
+     * ⚙️ Retrieves shop settings.
+     *
+     * This method retrieves the global configuration settings for the shop.
+     *
+     * 🛠 **Endpoint**: `GET /v1/shop/settings [SETTINGS-500]`
+     *
+     * 📤 **Returns**:
+     * A `Promise<SettingsResponse>` containing the shop settings, including:
+     * - `manualAccountCheck` (boolean): Indicates if manual account verification is enabled.
+     *
+     * @example
+     * ```typescript
+     * const settings = await client.auth.getSettings();
+     * console.log(settings.manualAccountCheck); // true
+     * ```
+     *
+     * @param context - Optional request context for SSR.
+     * @returns A promise that resolves with the shop settings.
+     */
+    getSettings(context?: RequestContext): Promise<SettingsResponse>;
+    /**
+     * 🏪 Retrieves store information.
+     *
+     * This method retrieves detailed information about a specific store by its identifier.
+     *
+     * 🛠 **Endpoint**: `GET /v1/shop/stores/{storeId} [STORE-500]`
+     *
+     * | Parameter  | Type     | Required | Description                          |
+     * |------------|----------|----------|--------------------------------------|
+     * | `storeId`  | `string` | ✅       | The unique identifier of the store.  |
+     *
+     * 📤 **Returns**:
+     * A `Promise<Store>` containing detailed store information, including:
+     * - `active`: Store activation status
+     * - `customFieldValues`: Custom field values
+     * - `description`: Store description
+     * - `externalId`: External identifier
+     * - `id`: Internal identifier
+     * - `name`: Store name
+     * - `storeLocales`: Localization information
+     *
+     * @example
+     * ```typescript
+     * const store = await client.auth.getStore({
+     *   storeId: "123e4567-e89b-12d3-a456-426614174000"
+     * });
+     * console.log(store.name); // "My Store"
+     * console.log(store.active); // true
+     * ```
+     *
+     * @param params - The parameters to retrieve the store.
+     * @param context - Optional request context for SSR.
+     * @throws {ValidationError} If the `storeId` parameter is missing.
+     * @throws {NotFoundError} If the store is not found.
+     * @returns A promise that resolves with the store information.
+     */
+    getStore(params: GetStoreParams, context?: RequestContext): Promise<Store>;
+}
+//# sourceMappingURL=auth.service.d.ts.map

package/dist/services/auth/auth.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.service.d.ts","sourceRoot":"","sources":["../../../src/services/auth/auth.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAE7D,OAAO,KAAK,EACV,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,4BAA4B,EAC5B,WAAW,EACX,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,gBAAgB,EAChB,KAAK,EACN,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,WAAY,SAAQ,WAAW;IAC1C,QAAQ,CAAC,WAAW,UAAU;IAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,YAAY,CAChB,MAAM,EAAE,kBAAkB,EAC1B,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,OAAO,CAAC;IAanB;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,YAAY,CAChB,MAAM,EAAE,kBAAkB,EAC1B,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,oBAAoB,CAAC;IA2ChC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,aAAa,CACjB,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,IAAI,CAAC;IAgBhB;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,sBAAsB,CAC1B,MAAM,EAAE,4BAA4B,EACpC,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,IAAI,CAAC;IAgBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACG,KAAK,CACT,MAAM,EAAE,WAAW,EACnB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,aAAa,CAAC;IA0CzB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACG,MAAM,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAgCrD;;;;;;;;;;;;;;;;;;;OAmBG;IACG,WAAW,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAUtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACG,QAAQ,CACZ,MAAM,EAAE,cAAc,EACtB,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,KAAK,CAAC;CAWlB"}