@flexbe/sdk 0.2.35 → 0.2.38

package/dist/browser/client/auth.js

@@ -0,0 +1,74 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { FlexbeAuthType } from '../types';
+import { TokenManager } from './token-manager';
+export class FlexbeAuth {
+    constructor(config) {
+        this.initialized = false;
+        this.initializationPromise = null;
+        this.config = config;
+        this.tokenManager = TokenManager.getInstance();
+        if (this.config.authType === FlexbeAuthType.BEARER) {
+            // Start initialization but don't wait for it
+            this.initializationPromise = this.initialize();
+        }
+        else {
+            this.initialized = true;
+        }
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const token = yield this.tokenManager.getToken();
+                this.initialized = !!token;
+            }
+            catch (error) {
+                console.error('Failed to initialize auth:', error);
+                this.initialized = false;
+            }
+            finally {
+                this.initializationPromise = null;
+            }
+        });
+    }
+    ensureInitialized() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.config.authType !== FlexbeAuthType.BEARER || this.initialized) {
+                return;
+            }
+            // If initialization is in progress, wait for it
+            if (this.initializationPromise) {
+                yield this.initializationPromise;
+                return;
+            }
+            // If not initialized and no initialization in progress, start one
+            yield this.initialize();
+        });
+    }
+    getAuthHeaders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.ensureInitialized();
+            const headers = {
+                'Content-Type': 'application/json',
+            };
+            if (this.config.authType === FlexbeAuthType.API_KEY) {
+                headers['x-api-key'] = this.config.apiKey;
+            }
+            else if (this.config.authType === FlexbeAuthType.BEARER) {
+                const token = yield this.tokenManager.getToken();
+                if (!token) {
+                    throw new Error('No valid bearer token available');
+                }
+                headers['Authorization'] = `Bearer ${token}`;
+            }
+            return headers;
+        });
+    }
+}

package/dist/browser/client/pages.js

@@ -316,6 +316,22 @@ export class Pages {
      * @throws {ServerException} When the server encounters an error
      * @throws {TimeoutException} When the request times out
      */
+    getVersions(pageId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.api.get(`/sites/${this.siteId}/pages/${pageId}/versions`);
+            return response.data;
+        });
+    }
+    /**
+     * @deprecated Use getVersions instead, remove it after frontend will be updated
+     * @param pageId - ID of the page to get versions for
+     * @returns List of page versions
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
     getPageVersions(pageId) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.api.get(`/sites/${this.siteId}/pages/${pageId}/versions`);
@@ -325,7 +341,7 @@ export class Pages {
     /**
      * Get a specific page version
      * @param pageId - ID of the page
-     * @param versionId - ID of the version to get
+     * @param versionId - ID of the version to get or 'published' to get the published version
      * @returns The requested page version with data
      * @throws {UnauthorizedException} When the API key is invalid or expired
      * @throws {NotFoundException} When the page or version is not found
@@ -333,10 +349,46 @@ export class Pages {
      * @throws {ServerException} When the server encounters an error
      * @throws {TimeoutException} When the request times out
      */
-    getPageVersion(pageId, versionId) {
+    getVersion(pageId, versionId) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield this.api.get(`/sites/${this.siteId}/pages/${pageId}/versions/${versionId}`);
             return response.data;
         });
     }
+    /**
+     * Get the published version of a page
+     * @param pageId - ID of the page
+     * @returns The published page version with data
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found or has no published version
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    getPublishedVersion(pageId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getVersion(pageId, 'published');
+        });
+    }
+    /**
+     * Create a new page version
+     * @param pageId - ID of the page to create version for
+     * @param data - Version data including:
+     * - data: Page data structure containing blocks, modals, widgets, etc.
+     * - assets: Optional page assets (images, files, screenshot)
+     * - publish: Whether to publish this version immediately (default: true)
+     * @returns The created page version with data
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {BadRequestException} When the version data is invalid
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    createVersion(pageId, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.api.post(`/sites/${this.siteId}/pages/${pageId}/versions`, data);
+            return response.data;
+        });
+    }
 }

package/dist/cjs/client/auth.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlexbeAuth = void 0;
+const types_1 = require("../types");
+const token_manager_1 = require("./token-manager");
+class FlexbeAuth {
+    constructor(config) {
+        this.initialized = false;
+        this.initializationPromise = null;
+        this.config = config;
+        this.tokenManager = token_manager_1.TokenManager.getInstance();
+        if (this.config.authType === types_1.FlexbeAuthType.BEARER) {
+            // Start initialization but don't wait for it
+            this.initializationPromise = this.initialize();
+        }
+        else {
+            this.initialized = true;
+        }
+    }
+    async initialize() {
+        try {
+            const token = await this.tokenManager.getToken();
+            this.initialized = !!token;
+        }
+        catch (error) {
+            console.error('Failed to initialize auth:', error);
+            this.initialized = false;
+        }
+        finally {
+            this.initializationPromise = null;
+        }
+    }
+    async ensureInitialized() {
+        if (this.config.authType !== types_1.FlexbeAuthType.BEARER || this.initialized) {
+            return;
+        }
+        // If initialization is in progress, wait for it
+        if (this.initializationPromise) {
+            await this.initializationPromise;
+            return;
+        }
+        // If not initialized and no initialization in progress, start one
+        await this.initialize();
+    }
+    async getAuthHeaders() {
+        await this.ensureInitialized();
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.config.authType === types_1.FlexbeAuthType.API_KEY) {
+            headers['x-api-key'] = this.config.apiKey;
+        }
+        else if (this.config.authType === types_1.FlexbeAuthType.BEARER) {
+            const token = await this.tokenManager.getToken();
+            if (!token) {
+                throw new Error('No valid bearer token available');
+            }
+            headers['Authorization'] = `Bearer ${token}`;
+        }
+        return headers;
+    }
+}
+exports.FlexbeAuth = FlexbeAuth;

package/dist/cjs/client/pages.js

@@ -283,6 +283,20 @@ class Pages {
      * @throws {ServerException} When the server encounters an error
      * @throws {TimeoutException} When the request times out
      */
+    async getVersions(pageId) {
+        const response = await this.api.get(`/sites/${this.siteId}/pages/${pageId}/versions`);
+        return response.data;
+    }
+    /**
+     * @deprecated Use getVersions instead, remove it after frontend will be updated
+     * @param pageId - ID of the page to get versions for
+     * @returns List of page versions
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
     async getPageVersions(pageId) {
         const response = await this.api.get(`/sites/${this.siteId}/pages/${pageId}/versions`);
         return response.data;
@@ -290,7 +304,7 @@ class Pages {
     /**
      * Get a specific page version
      * @param pageId - ID of the page
-     * @param versionId - ID of the version to get
+     * @param versionId - ID of the version to get or 'published' to get the published version
      * @returns The requested page version with data
      * @throws {UnauthorizedException} When the API key is invalid or expired
      * @throws {NotFoundException} When the page or version is not found
@@ -298,9 +312,41 @@ class Pages {
      * @throws {ServerException} When the server encounters an error
      * @throws {TimeoutException} When the request times out
      */
-    async getPageVersion(pageId, versionId) {
+    async getVersion(pageId, versionId) {
         const response = await this.api.get(`/sites/${this.siteId}/pages/${pageId}/versions/${versionId}`);
         return response.data;
     }
+    /**
+     * Get the published version of a page
+     * @param pageId - ID of the page
+     * @returns The published page version with data
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found or has no published version
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    async getPublishedVersion(pageId) {
+        return this.getVersion(pageId, 'published');
+    }
+    /**
+     * Create a new page version
+     * @param pageId - ID of the page to create version for
+     * @param data - Version data including:
+     * - data: Page data structure containing blocks, modals, widgets, etc.
+     * - assets: Optional page assets (images, files, screenshot)
+     * - publish: Whether to publish this version immediately (default: true)
+     * @returns The created page version with data
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {BadRequestException} When the version data is invalid
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    async createVersion(pageId, data) {
+        const response = await this.api.post(`/sites/${this.siteId}/pages/${pageId}/versions`, data);
+        return response.data;
+    }
 }
 exports.Pages = Pages;

package/dist/client/flexbe-client.d.ts

@@ -0,0 +1,13 @@
+import { AxiosRequestConfig } from 'axios';
+import { FlexbeConfig, FlexbeResponse } from '../types';
+export declare class FlexbeClient {
+    private readonly client;
+    private readonly config;
+    constructor(config: FlexbeConfig);
+    private setupInterceptors;
+    protected request<T>(config: AxiosRequestConfig): Promise<FlexbeResponse<T>>;
+    protected get<T>(url: string, config?: AxiosRequestConfig): Promise<FlexbeResponse<T>>;
+    protected post<T>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<FlexbeResponse<T>>;
+    protected put<T>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<FlexbeResponse<T>>;
+    protected delete<T>(url: string, config?: AxiosRequestConfig): Promise<FlexbeResponse<T>>;
+}

package/dist/client/flexbe-client.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlexbeClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class FlexbeClient {
+    constructor(config) {
+        this.config = {
+            baseUrl: config.baseUrl || 'https://api.flexbe.com',
+            timeout: config.timeout || 30000,
+            ...config,
+        };
+        this.client = axios_1.default.create({
+            baseURL: this.config.baseUrl,
+            timeout: this.config.timeout,
+            headers: {
+                'Authorization': `Bearer ${this.config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        this.setupInterceptors();
+    }
+    setupInterceptors() {
+        this.client.interceptors.response.use((response) => response, (error) => {
+            const flexbeError = {
+                message: error.response?.data?.message || error.message,
+                code: error.response?.data?.code,
+                status: error.response?.status,
+                details: error.response?.data?.details,
+            };
+            return Promise.reject(flexbeError);
+        });
+    }
+    async request(config) {
+        try {
+            const response = await this.client.request(config);
+            return {
+                data: response.data,
+                status: response.status,
+                statusText: response.statusText,
+            };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    get(url, config) {
+        return this.request({ ...config, method: 'GET', url });
+    }
+    post(url, data, config) {
+        return this.request({ ...config, method: 'POST', url, data });
+    }
+    put(url, data, config) {
+        return this.request({ ...config, method: 'PUT', url, data });
+    }
+    delete(url, config) {
+        return this.request({ ...config, method: 'DELETE', url });
+    }
+}
+exports.FlexbeClient = FlexbeClient;

package/dist/esm/client/auth.js

@@ -0,0 +1,59 @@
+import { FlexbeAuthType } from '../types';
+import { TokenManager } from './token-manager';
+export class FlexbeAuth {
+    constructor(config) {
+        this.initialized = false;
+        this.initializationPromise = null;
+        this.config = config;
+        this.tokenManager = TokenManager.getInstance();
+        if (this.config.authType === FlexbeAuthType.BEARER) {
+            // Start initialization but don't wait for it
+            this.initializationPromise = this.initialize();
+        }
+        else {
+            this.initialized = true;
+        }
+    }
+    async initialize() {
+        try {
+            const token = await this.tokenManager.getToken();
+            this.initialized = !!token;
+        }
+        catch (error) {
+            console.error('Failed to initialize auth:', error);
+            this.initialized = false;
+        }
+        finally {
+            this.initializationPromise = null;
+        }
+    }
+    async ensureInitialized() {
+        if (this.config.authType !== FlexbeAuthType.BEARER || this.initialized) {
+            return;
+        }
+        // If initialization is in progress, wait for it
+        if (this.initializationPromise) {
+            await this.initializationPromise;
+            return;
+        }
+        // If not initialized and no initialization in progress, start one
+        await this.initialize();
+    }
+    async getAuthHeaders() {
+        await this.ensureInitialized();
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.config.authType === FlexbeAuthType.API_KEY) {
+            headers['x-api-key'] = this.config.apiKey;
+        }
+        else if (this.config.authType === FlexbeAuthType.BEARER) {
+            const token = await this.tokenManager.getToken();
+            if (!token) {
+                throw new Error('No valid bearer token available');
+            }
+            headers['Authorization'] = `Bearer ${token}`;
+        }
+        return headers;
+    }
+}

package/dist/esm/client/pages.js

@@ -280,6 +280,20 @@ export class Pages {
      * @throws {ServerException} When the server encounters an error
      * @throws {TimeoutException} When the request times out
      */
+    async getVersions(pageId) {
+        const response = await this.api.get(`/sites/${this.siteId}/pages/${pageId}/versions`);
+        return response.data;
+    }
+    /**
+     * @deprecated Use getVersions instead, remove it after frontend will be updated
+     * @param pageId - ID of the page to get versions for
+     * @returns List of page versions
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
     async getPageVersions(pageId) {
         const response = await this.api.get(`/sites/${this.siteId}/pages/${pageId}/versions`);
         return response.data;
@@ -287,7 +301,7 @@ export class Pages {
     /**
      * Get a specific page version
      * @param pageId - ID of the page
-     * @param versionId - ID of the version to get
+     * @param versionId - ID of the version to get or 'published' to get the published version
      * @returns The requested page version with data
      * @throws {UnauthorizedException} When the API key is invalid or expired
      * @throws {NotFoundException} When the page or version is not found
@@ -295,8 +309,40 @@ export class Pages {
      * @throws {ServerException} When the server encounters an error
      * @throws {TimeoutException} When the request times out
      */
-    async getPageVersion(pageId, versionId) {
+    async getVersion(pageId, versionId) {
         const response = await this.api.get(`/sites/${this.siteId}/pages/${pageId}/versions/${versionId}`);
         return response.data;
     }
+    /**
+     * Get the published version of a page
+     * @param pageId - ID of the page
+     * @returns The published page version with data
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found or has no published version
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    async getPublishedVersion(pageId) {
+        return this.getVersion(pageId, 'published');
+    }
+    /**
+     * Create a new page version
+     * @param pageId - ID of the page to create version for
+     * @param data - Version data including:
+     * - data: Page data structure containing blocks, modals, widgets, etc.
+     * - assets: Optional page assets (images, files, screenshot)
+     * - publish: Whether to publish this version immediately (default: true)
+     * @returns The created page version with data
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {BadRequestException} When the version data is invalid
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    async createVersion(pageId, data) {
+        const response = await this.api.post(`/sites/${this.siteId}/pages/${pageId}/versions`, data);
+        return response.data;
+    }
 }

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './client/flexbe-client';

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./client/flexbe-client"), exports);

package/dist/src/client/flexbe-client.d.ts

@@ -0,0 +1,20 @@
+import { AxiosRequestConfig } from 'axios';
+import { FlexbeConfig, FlexbeResponse } from '../types';
+import { PagesClient } from './pages-client';
+export declare class FlexbeClient {
+    private readonly client;
+    private readonly config;
+    readonly pages: PagesClient;
+    constructor(config?: Partial<FlexbeConfig>);
+    private setupInterceptors;
+    private request;
+    private get;
+    private post;
+    private put;
+    private delete;
+    private getSiteUrl;
+    sitesGet<T>(path: string, config?: AxiosRequestConfig): Promise<FlexbeResponse<T>>;
+    sitesPost<T>(path: string, data?: unknown, config?: AxiosRequestConfig): Promise<FlexbeResponse<T>>;
+    sitesPut<T>(path: string, data?: unknown, config?: AxiosRequestConfig): Promise<FlexbeResponse<T>>;
+    sitesDelete<T>(path: string, config?: AxiosRequestConfig): Promise<FlexbeResponse<T>>;
+}

package/dist/src/client/flexbe-client.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlexbeClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const pages_client_1 = require("./pages-client");
+class FlexbeClient {
+    constructor(config) {
+        this.config = {
+            baseUrl: config?.baseUrl || process.env.FLEXBE_API_URL || 'https://api.flexbe.com',
+            timeout: config?.timeout || 30000,
+            apiKey: config?.apiKey || process.env.FLEXBE_API_KEY || '',
+            siteId: config?.siteId || process.env.FLEXBE_SITE_ID,
+        };
+        if (!this.config.apiKey) {
+            throw new Error('API key is required. Please provide it either through config or FLEXBE_API_KEY environment variable.');
+        }
+        this.client = axios_1.default.create({
+            baseURL: this.config.baseUrl,
+            timeout: this.config.timeout,
+            headers: {
+                'Authorization': `Bearer ${this.config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        this.setupInterceptors();
+        this.pages = new pages_client_1.PagesClient(this);
+    }
+    setupInterceptors() {
+        this.client.interceptors.response.use((response) => response, (error) => {
+            const flexbeError = {
+                message: error.response?.data?.message || error.message,
+                code: error.response?.data?.code,
+                status: error.response?.status,
+                details: error.response?.data?.details,
+            };
+            return Promise.reject(flexbeError);
+        });
+    }
+    async request(config) {
+        try {
+            const response = await this.client.request(config);
+            return {
+                data: response.data,
+                status: response.status,
+                statusText: response.statusText,
+            };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    get(url, config) {
+        return this.request({ ...config, method: 'GET', url });
+    }
+    post(url, data, config) {
+        return this.request({ ...config, method: 'POST', url, data });
+    }
+    put(url, data, config) {
+        return this.request({ ...config, method: 'PUT', url, data });
+    }
+    delete(url, config) {
+        return this.request({ ...config, method: 'DELETE', url });
+    }
+    getSiteUrl(path) {
+        if (!this.config.siteId) {
+            return path;
+        }
+        return `/sites/${this.config.siteId}${path}`;
+    }
+    sitesGet(path, config) {
+        return this.get(this.getSiteUrl(path), config);
+    }
+    sitesPost(path, data, config) {
+        return this.post(this.getSiteUrl(path), data, config);
+    }
+    sitesPut(path, data, config) {
+        return this.put(this.getSiteUrl(path), data, config);
+    }
+    sitesDelete(path, config) {
+        return this.delete(this.getSiteUrl(path), config);
+    }
+}
+exports.FlexbeClient = FlexbeClient;

package/dist/src/client/pages-client.d.ts

@@ -0,0 +1,14 @@
+import { Page, GetPagesParams, PageListResponse } from '../types/pages';
+import { FlexbeClient } from './flexbe-client';
+export declare class PagesClient {
+    private readonly client;
+    constructor(client: FlexbeClient);
+    /**
+     * Get list of pages for a site
+     */
+    getPages(params?: GetPagesParams): Promise<PageListResponse>;
+    /**
+     * Get a single page by ID
+     */
+    getPage(pageId: number): Promise<Page>;
+}

package/dist/src/client/pages-client.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PagesClient = void 0;
+class PagesClient {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get list of pages for a site
+     */
+    async getPages(params) {
+        const response = await this.client.sitesGet('/pages', { params });
+        return response.data;
+    }
+    /**
+     * Get a single page by ID
+     */
+    async getPage(pageId) {
+        const response = await this.client.sitesGet(`/pages/${pageId}`);
+        return response.data;
+    }
+}
+exports.PagesClient = PagesClient;

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from './client/flexbe-client';
+export * from './client/pages-client';
+export * from './types';
+export * from './types/pages';

package/dist/src/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client/flexbe-client"), exports);
+__exportStar(require("./client/pages-client"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./types/pages"), exports);

package/dist/src/types/index.d.ts

@@ -0,0 +1,23 @@
+export interface FlexbeConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    timeout?: number;
+    siteId?: string;
+}
+export interface FlexbeResponse<T> {
+    data: T;
+    status: number;
+    statusText: string;
+}
+export interface FlexbeErrorResponse {
+    message: string;
+    code?: string;
+    details?: unknown;
+}
+export interface FlexbeError {
+    message: string;
+    code?: string;
+    status?: number;
+    details?: unknown;
+}
+export type FlexbeAuthType = 'apiKey' | 'bearer' | 'oauth2';

package/dist/src/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/types/pages.d.ts

@@ -0,0 +1,41 @@
+export declare enum PageType {
+    PAGE = "page",
+    FILE = "file",
+    GLOBAL = "global",
+    AI = "ai",
+    CMS = "cms",
+    ECOMMERCE_PRODUCT = "ecommerce_product",
+    ECOMMERCE_CATEGORY = "ecommerce_category"
+}
+export declare enum PageStatus {
+    PUBLISHED = "published",
+    DRAFTED = "drafted",
+    DELETED = "deleted"
+}
+export interface Page {
+    id: number;
+    siteId: number;
+    type: PageType;
+    uri: string;
+    title: string | null;
+    status: PageStatus;
+    updatedAt?: Date;
+    imgId: number | null;
+    sortIndex: number;
+}
+export interface GetPagesParams {
+    offset?: number;
+    limit?: number;
+    type?: PageType;
+    status?: PageStatus;
+    search?: string;
+}
+export interface Pagination {
+    limit: number;
+    offset: number;
+    total: number;
+}
+export interface PageListResponse {
+    pages: Page[];
+    pagination: Pagination;
+}

package/dist/src/types/pages.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageStatus = exports.PageType = void 0;
+var PageType;
+(function (PageType) {
+    PageType["PAGE"] = "page";
+    PageType["FILE"] = "file";
+    PageType["GLOBAL"] = "global";
+    PageType["AI"] = "ai";
+    PageType["CMS"] = "cms";
+    PageType["ECOMMERCE_PRODUCT"] = "ecommerce_product";
+    PageType["ECOMMERCE_CATEGORY"] = "ecommerce_category";
+})(PageType || (exports.PageType = PageType = {}));
+var PageStatus;
+(function (PageStatus) {
+    PageStatus["PUBLISHED"] = "published";
+    PageStatus["DRAFTED"] = "drafted";
+    PageStatus["DELETED"] = "deleted";
+})(PageStatus || (exports.PageStatus = PageStatus = {}));

package/dist/test/client/flexbe-client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/client/flexbe-client.test.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const flexbe_client_1 = require("../../src/client/flexbe-client");
+describe('FlexbeClient', () => {
+    let client;
+    const testConfig = {
+        apiKey: process.env.FLEXBE_API_KEY || 'test-api-key',
+        baseUrl: process.env.FLEXBE_API_URL || 'https://api.flexbe.com',
+    };
+    beforeEach(() => {
+        client = new flexbe_client_1.FlexbeClient(testConfig);
+    });
+    it('should initialize with correct configuration', () => {
+        expect(client).toBeDefined();
+        const axiosInstance = client.client;
+        expect(axiosInstance.defaults.baseURL).toBe(testConfig.baseUrl);
+        expect(axiosInstance.defaults.headers.Authorization).toBe(`Bearer ${testConfig.apiKey}`);
+    });
+    it('should handle successful GET request', async () => {
+        // Access protected method for testing
+        const response = await client.get('/');
+        expect(response).toBeDefined();
+        expect(response.status).toBe(200);
+        expect(response.data).toBeDefined();
+    });
+    it('should handle error response', async () => {
+        try {
+            // Access protected method for testing
+            await client.get('/non-existent-endpoint');
+            fail('Should have thrown an error');
+        }
+        catch (error) {
+            const flexbeError = error;
+            expect(flexbeError.message).toBeDefined();
+            expect(flexbeError.status).toBeDefined();
+        }
+    });
+});

package/dist/test/client/pages-client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/client/pages-client.test.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const flexbe_client_1 = require("../../src/client/flexbe-client");
+const pages_1 = require("../../src/types/pages");
+describe('PagesClient', () => {
+    let client;
+    const testConfig = {
+        apiKey: process.env.FLEXBE_API_KEY || 'test-api-key',
+        baseUrl: process.env.FLEXBE_API_URL || 'https://api.flexbe.com',
+        siteId: process.env.FLEXBE_SITE_ID || '0',
+    };
+    beforeEach(() => {
+        client = new flexbe_client_1.FlexbeClient(testConfig);
+    });
+    it('should initialize with correct configuration', () => {
+        expect(client.pages).toBeDefined();
+        const axiosInstance = client.client;
+        expect(axiosInstance.defaults.baseURL).toBe(testConfig.baseUrl);
+        expect(axiosInstance.defaults.headers.Authorization).toBe(`Bearer ${testConfig.apiKey}`);
+    });
+    it('should get list of pages with default parameters', async () => {
+        const response = await client.pages.getPages();
+        expect(response).toBeDefined();
+        expect(response.pages).toBeDefined();
+        expect(response.pagination).toBeDefined();
+        expect(response.pagination.limit).toBe(10);
+        expect(response.pagination.offset).toBe(0);
+        expect(response.pagination.total).toBeDefined();
+    });
+    it('should get list of pages with custom parameters', async () => {
+        const params = {
+            offset: 0,
+            limit: 20,
+            type: pages_1.PageType.PAGE,
+            status: pages_1.PageStatus.PUBLISHED,
+            search: ''
+        };
+        const response = await client.pages.getPages(params);
+        expect(response).toBeDefined();
+        expect(response.pages).toBeDefined();
+        expect(response.pagination).toBeDefined();
+        expect(response.pagination.limit).toBe(params.limit);
+        expect(response.pagination.offset).toBe(params.offset);
+        expect(response.pagination.total).toBeDefined();
+    });
+    it('should get a single page by ID', async () => {
+        const pageId = 2272741;
+        const response = await client.pages.getPage(pageId);
+        expect(response).toBeDefined();
+        expect(response.id).toBe(pageId);
+        expect(response.siteId).toBe(Number(testConfig.siteId));
+        expect(response.type).toBeDefined();
+        expect(response.uri).toBeDefined();
+        expect(response.status).toBeDefined();
+        expect(response.sortIndex).toBeDefined();
+    });
+    it('should handle error when getting non-existent page', async () => {
+        try {
+            await client.pages.getPage(999999);
+            fail('Should have thrown an error');
+        }
+        catch (error) {
+            const flexbeError = error;
+            expect(flexbeError.message).toBeDefined();
+            expect(flexbeError.status).toBeDefined();
+        }
+    });
+    it('should handle error when getting pages with invalid parameters', async () => {
+        try {
+            await client.pages.getPages({
+                offset: -1,
+                limit: 0
+            });
+            fail('Should have thrown an error');
+        }
+        catch (error) {
+            const flexbeError = error;
+            expect(flexbeError.message).toBeDefined();
+            expect(flexbeError.status).toBeDefined();
+        }
+    });
+});

package/dist/types/client/auth.d.ts

@@ -0,0 +1,11 @@
+import { FlexbeConfig } from '../types';
+export declare class FlexbeAuth {
+    private readonly config;
+    private readonly tokenManager;
+    private initialized;
+    private initializationPromise;
+    constructor(config: FlexbeConfig);
+    private initialize;
+    ensureInitialized(): Promise<void>;
+    getAuthHeaders(): Promise<Record<string, string>>;
+}

package/dist/types/client/pages.d.ts

@@ -1,5 +1,5 @@
-import type { ApiClient } from './api-client';
-import type { BulkDeleteResponse, BulkUpdateFolderItem, BulkUpdateFolderResponse, BulkUpdatePageItem, BulkUpdateResponse, CreateFolderParams, GetPagesParams, Page, PageContent, PageFolder, PageFolderListResponse, PageHistoryItemData, PageHistoryListResponse, PageListResponse, PageVersionDataResponse, PageVersionListResponse, UpdateFolderParams, UpdatePageContentParams, UpdatePageParams } from '../types/pages';
+import { ApiClient } from './api-client';
+import { BulkDeleteResponse, BulkUpdateFolderItem, BulkUpdateFolderResponse, BulkUpdatePageItem, BulkUpdateResponse, CreateFolderParams, CreatePageVersionParams, GetPagesParams, Page, PageContent, PageFolder, PageFolderListResponse, PageHistoryItemData, PageHistoryListResponse, PageListResponse, PageVersionDataResponse, PageVersionListResponse, UpdateFolderParams, UpdatePageContentParams, UpdatePageParams } from '../types/pages';
 export declare class Pages {
     private readonly api;
     private readonly siteId;
@@ -226,11 +226,22 @@ export declare class Pages {
      * @throws {ServerException} When the server encounters an error
      * @throws {TimeoutException} When the request times out
      */
+    getVersions(pageId: number): Promise<PageVersionListResponse>;
+    /**
+     * @deprecated Use getVersions instead, remove it after frontend will be updated
+     * @param pageId - ID of the page to get versions for
+     * @returns List of page versions
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
     getPageVersions(pageId: number): Promise<PageVersionListResponse>;
     /**
      * Get a specific page version
      * @param pageId - ID of the page
-     * @param versionId - ID of the version to get
+     * @param versionId - ID of the version to get or 'published' to get the published version
      * @returns The requested page version with data
      * @throws {UnauthorizedException} When the API key is invalid or expired
      * @throws {NotFoundException} When the page or version is not found
@@ -238,5 +249,32 @@ export declare class Pages {
      * @throws {ServerException} When the server encounters an error
      * @throws {TimeoutException} When the request times out
      */
-    getPageVersion(pageId: number, versionId: number): Promise<PageVersionDataResponse>;
+    getVersion(pageId: number, versionId: number | 'published'): Promise<PageVersionDataResponse>;
+    /**
+     * Get the published version of a page
+     * @param pageId - ID of the page
+     * @returns The published page version with data
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found or has no published version
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    getPublishedVersion(pageId: number): Promise<PageVersionDataResponse>;
+    /**
+     * Create a new page version
+     * @param pageId - ID of the page to create version for
+     * @param data - Version data including:
+     * - data: Page data structure containing blocks, modals, widgets, etc.
+     * - assets: Optional page assets (images, files, screenshot)
+     * - publish: Whether to publish this version immediately (default: true)
+     * @returns The created page version with data
+     * @throws {UnauthorizedException} When the API key is invalid or expired
+     * @throws {NotFoundException} When the page is not found
+     * @throws {ForbiddenException} When the page does not belong to the site
+     * @throws {BadRequestException} When the version data is invalid
+     * @throws {ServerException} When the server encounters an error
+     * @throws {TimeoutException} When the request times out
+     */
+    createVersion(pageId: number, data: CreatePageVersionParams): Promise<PageVersionDataResponse>;
 }

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/types/pages.d.ts

@@ -98,6 +98,15 @@ export interface UpdatePageParams {
     sortIndex?: number;
     meta?: Partial<PageMeta>;
 }
+export interface CreatePageVersionParams {
+    data: PageDataStructure;
+    assets?: {
+        images: number[];
+        files: string[];
+        screenshot?: number | null;
+    };
+    publish?: boolean;
+}
 export interface BulkUpdatePageItem extends UpdatePageParams {
     id: number;
 }
@@ -307,7 +316,19 @@ export interface PageVersionItem {
 export interface PageVersionListResponse {
     list: PageVersionItem[];
 }
-export interface PageVersionDataResponse {
-    data: PageContent;
+export interface PageDataStructure {
+    is: string;
+    template_id: string;
+    blocks: PageBlock[];
+    modals: PageModal[];
+    widgets: PageWidget[];
+    codes: string[];
+    abtests: PageABTest[];
+    background: PageBackground;
+    textStyles: TextStyleItem[];
+    responsive: string | boolean;
+}
+export interface PageVersionDataResponse extends PageVersionItem {
+    data: PageDataStructure;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flexbe/sdk",
-  "version": "0.2.35",
+  "version": "0.2.38",
   "description": "TypeScript SDK for Flexbe API",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -23,7 +23,7 @@
     "lint": "eslint src --ext .ts",
     "format": "prettier --write \"src/**/*.ts\"",
     "prepare": "npm run build",
-    "prepublishOnly_": "npm test && npm run lint"
+    "prepublishOnly": "npm test && npm run lint"
   },
   "keywords": [
     "flexbe",