@blux.ai/web-sdk 0.0.3

package/.prettierrc

@@ -0,0 +1,5 @@
+{
+  "printWidth": 120,
+  "tabWidth": 2,
+  "singleQuote": false
+}

package/.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "editor.formatOnSave": true,
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": "explicit"
+  }
+}

package/LICENSE

@@ -0,0 +1 @@
+(c) Copyright 2024 Z.Ai Inc. All rights reserved.

package/README.md

@@ -0,0 +1,21 @@
+# @blux.ai/web-sdk
+
+The BluxClient Web SDK Library is a set of methods attached to a global bluxclient object intended to be used by websites wishing to send data to Blux collector api.
+
+### Requirements
+
+---
+
+- [Node.js](https://github.com/nodejs/node) >= 10.24.1 (ES6 2015 지원)
+- TypeScript (권장)
+
+### Installation
+
+---
+
+```shell
+// NPM 이용
+npm install @blux.ai/web-sdk
+// Yarn 이용
+yarn add @blux.ai/web-sdk
+```

package/dist/BluxClient.d.ts

@@ -0,0 +1,17 @@
+import { Request } from "./requests/Request";
+export default class BluxClient {
+    static sdkInfo: {
+        type: string;
+        version: string;
+    };
+    static bluxClientID: string | null;
+    static bluxAPIKey: string | null;
+    static init({ bluxClientId, bluxAPIKey }: {
+        bluxClientId: string;
+        bluxAPIKey: string;
+    }): void;
+    static setLogLevel(logLevel: "trace" | "debug" | "info" | "warn" | "error"): void;
+    protected static deviceRegisterOrActivate(): void;
+    static setUserId(userId: string | null): void;
+    static sendRequest(request: Request | Request[]): void;
+}

package/dist/BluxClient.js

@@ -0,0 +1,104 @@
+"use strict";
+exports.__esModule = true;
+var BaseErrorHandler_1 = require("./core/BaseErrorHandler");
+var HTTPClient_1 = require("./core/HTTPClient");
+var LocalStorage_1 = require("./core/LocalStorage");
+var Logger_1 = require("./core/Logger");
+var ActivateDevice_1 = require("./requests/Devices/ActivateDevice");
+var CreateDevice_1 = require("./requests/Devices/CreateDevice");
+var UpdateDevice_1 = require("./requests/Devices/UpdateDevice");
+var types_1 = require("./utils/types");
+var BluxClient = /** @class */ (function () {
+    function BluxClient() {
+    }
+    BluxClient.init = function (_a) {
+        var bluxClientId = _a.bluxClientId, bluxAPIKey = _a.bluxAPIKey;
+        try {
+            Logger_1.Logger.debug("Init with client id: " + bluxClientId);
+            BluxClient.bluxClientID = bluxClientId;
+            BluxClient.bluxAPIKey = bluxAPIKey;
+            BluxClient.deviceRegisterOrActivate();
+        }
+        catch (e) {
+            BaseErrorHandler_1.BaseErrorHandler.handle(e);
+        }
+    };
+    BluxClient.setLogLevel = function (logLevel) {
+        Logger_1.Logger.setLevel(logLevel);
+    };
+    BluxClient.deviceRegisterOrActivate = function () {
+        try {
+            var clientId = BluxClient.bluxClientID;
+            var deviceId = LocalStorage_1.LocalStorage.getDeviceId();
+            var bluxId = LocalStorage_1.LocalStorage.getBluxId();
+            if ((0, types_1.isNullOrUndefined)(clientId) || (clientId && (0, types_1.isEmptyString)(clientId))) {
+                throw new Error("Client ID is not intialized. Please initialize BluxClient.");
+            }
+            if (!deviceId || !bluxId) {
+                // Create Device 호출 -> bluxId, deviceId 저장
+                Logger_1.Logger.debug("Saved Device ID and Blux ID are not exists, newly registered.");
+                var createDeviceRequest = new CreateDevice_1.CreateDevice();
+                HTTPClient_1.HTTPClient.sendRequestWithBody(createDeviceRequest).then(function (response) {
+                    if (response) {
+                        LocalStorage_1.LocalStorage.setBluxId(response.blux_id);
+                        LocalStorage_1.LocalStorage.setDeviceId(response.device_id);
+                    }
+                });
+            }
+            else {
+                Logger_1.Logger.debug("Saved Device ID and Blux ID are exists : " + deviceId + " | " + bluxId);
+                // Activate Device 호출
+                var activateDeviceRequest = new ActivateDevice_1.ActivateDevice(bluxId, deviceId);
+                HTTPClient_1.HTTPClient.sendRequestWithBody(activateDeviceRequest);
+            }
+        }
+        catch (e) {
+            BaseErrorHandler_1.BaseErrorHandler.handle(e);
+        }
+    };
+    BluxClient.setUserId = function (userId) {
+        try {
+            // localStorage로부터 device_id, blux_id를 가져온다.
+            var deviceId = LocalStorage_1.LocalStorage.getDeviceId();
+            var bluxId = LocalStorage_1.LocalStorage.getBluxId();
+            if (!deviceId || !bluxId) {
+                throw new Error("Both deviceId and bluxId are not found in localStorage. Please initialize BluxClient.");
+            }
+            var updateDeviceRequest = new UpdateDevice_1.UpdateDevice(bluxId, deviceId, userId);
+            HTTPClient_1.HTTPClient.sendRequestWithBody(updateDeviceRequest).then(function (response) {
+                var _a;
+                if (response) {
+                    LocalStorage_1.LocalStorage.setBluxId(response.blux_id);
+                    LocalStorage_1.LocalStorage.setDeviceId(response.device_id);
+                    LocalStorage_1.LocalStorage.setUserId((_a = response.user_id) !== null && _a !== void 0 ? _a : "undefined");
+                }
+            });
+        }
+        catch (e) {
+            BaseErrorHandler_1.BaseErrorHandler.handle(e);
+        }
+    };
+    BluxClient.sendRequest = function (request) {
+        try {
+            var bluxId = LocalStorage_1.LocalStorage.getBluxId();
+            var deviceId = LocalStorage_1.LocalStorage.getDeviceId();
+            var userId = LocalStorage_1.LocalStorage.getUserId();
+            // If either of bluxId or deviceId is not exists, do not send request.
+            if (!bluxId || !deviceId) {
+                throw new Error("Saved Blux ID and Device ID are not exists. Do not send event request.");
+            }
+            HTTPClient_1.HTTPClient.sendRequestWithBody(request, { bluxId: bluxId, deviceId: deviceId, userId: userId });
+        }
+        catch (e) {
+            BaseErrorHandler_1.BaseErrorHandler.handle(e);
+        }
+    };
+    BluxClient.sdkInfo = {
+        type: "browser",
+        version: "0.0.1"
+    };
+    BluxClient.bluxClientID = null;
+    BluxClient.bluxAPIKey = null;
+    return BluxClient;
+}());
+exports["default"] = BluxClient;

package/dist/core/BaseErrorHandler.d.ts

@@ -0,0 +1,3 @@
+export declare class BaseErrorHandler {
+    static handle(error: Error): void;
+}

package/dist/core/BaseErrorHandler.js

@@ -0,0 +1,13 @@
+"use strict";
+exports.__esModule = true;
+exports.BaseErrorHandler = void 0;
+var Logger_1 = require("./Logger");
+var BaseErrorHandler = /** @class */ (function () {
+    function BaseErrorHandler() {
+    }
+    BaseErrorHandler.handle = function (error) {
+        Logger_1.Logger.error(error.stack);
+    };
+    return BaseErrorHandler;
+}());
+exports.BaseErrorHandler = BaseErrorHandler;

package/dist/core/HTTPClient.d.ts

@@ -0,0 +1,10 @@
+import { Request } from "../requests/Request";
+export declare class HTTPClient {
+    private static COLLECTOR_BASE_URL;
+    static sendRequestWithBody<T>(request: Request | Request[], extraIdentifier?: {
+        bluxId: string;
+        deviceId: string;
+        userId: string | null;
+    }): Promise<T | undefined>;
+    private static generateHeaders;
+}

package/dist/core/HTTPClient.js

@@ -0,0 +1,122 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.HTTPClient = void 0;
+var BluxClient_1 = __importDefault(require("../BluxClient"));
+var BaseErrorHandler_1 = require("./BaseErrorHandler");
+var HTTPClient = /** @class */ (function () {
+    function HTTPClient() {
+    }
+    HTTPClient.sendRequestWithBody = function (request, extraIdentifier) {
+        return __awaiter(this, void 0, void 0, function () {
+            var clientId, apiKey, requestsArray, method, baseUrl, path, bodyArr, body, response, errorMessage, data, e_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        clientId = BluxClient_1["default"].bluxClientID;
+                        apiKey = BluxClient_1["default"].bluxAPIKey;
+                        if (!clientId || !apiKey) {
+                            throw new Error("Client ID and API Key are not initialized. Please initialize BluxClient.");
+                        }
+                        requestsArray = Array.isArray(request) ? request : [request];
+                        method = requestsArray[0].method;
+                        baseUrl = this.COLLECTOR_BASE_URL;
+                        path = requestsArray[0].path;
+                        bodyArr = requestsArray.map(function (req, idx) { return (__assign(__assign(__assign({}, req.getPayload()), { timestamp: req.getTimestamp() + 1e-6 * idx }), (extraIdentifier && {
+                            user_id: extraIdentifier.userId,
+                            blux_id: extraIdentifier.bluxId,
+                            device_id: extraIdentifier.deviceId
+                        }))); });
+                        body = bodyArr.length === 1 ? bodyArr[0] : bodyArr;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 6, , 7]);
+                        return [4 /*yield*/, fetch(baseUrl + path, {
+                                method: method,
+                                headers: this.generateHeaders(clientId, apiKey),
+                                body: JSON.stringify(body)
+                            })];
+                    case 2:
+                        response = _a.sent();
+                        if (!!response.ok) return [3 /*break*/, 4];
+                        return [4 /*yield*/, response.text()];
+                    case 3:
+                        errorMessage = _a.sent();
+                        throw new Error("Network API Call failed with status ".concat(response.status, " Error message: ").concat(errorMessage));
+                    case 4: return [4 /*yield*/, response.json()];
+                    case 5:
+                        data = _a.sent();
+                        return [2 /*return*/, data];
+                    case 6:
+                        e_1 = _a.sent();
+                        BaseErrorHandler_1.BaseErrorHandler.handle(e_1);
+                        return [2 /*return*/, undefined];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    HTTPClient.generateHeaders = function (clientId, apiKey) {
+        var headers = new Headers();
+        headers.append("Content-Type", "application/json;charset=UTF-8");
+        headers.append("Accept", "application/json");
+        var requestTimestamp = Math.floor(Date.now() / 1000).toString();
+        headers.append("X-BLUX-SDK-INFO", "".concat(BluxClient_1["default"].sdkInfo.type, "-").concat(BluxClient_1["default"].sdkInfo.version));
+        headers.append("X-BLUX-CLIENT-ID", clientId);
+        headers.append("X-BLUX-API-KEY", apiKey);
+        headers.append("X-BLUX-TIMESTAMP", requestTimestamp);
+        return headers;
+    };
+    HTTPClient.COLLECTOR_BASE_URL = " https://collector-api-web.blux.ai";
+    return HTTPClient;
+}());
+exports.HTTPClient = HTTPClient;

package/dist/core/LocalStorage.d.ts

@@ -0,0 +1,13 @@
+export declare class LocalStorage {
+    /**
+     * Used in BluxClient initialization to dedupe local storage.
+     */
+    static getLogLevel(): string | null;
+    static setLogLevel(loglevel: string): void;
+    static getBluxId(): string | null;
+    static setBluxId(bluxId: string): void;
+    static getDeviceId(): string | null;
+    static setDeviceId(deviceId: string): void;
+    static getUserId(): string | null;
+    static setUserId(userId: string): void;
+}

package/dist/core/LocalStorage.js

@@ -0,0 +1,43 @@
+"use strict";
+exports.__esModule = true;
+exports.LocalStorage = void 0;
+var BlUX_LOGLEVEL = "blux_loglevel";
+var BLUX_ID = "blux_id";
+var BLUX_DEVICE_ID = "blux_deviceId";
+var BLUX_USER_ID = "blux_userId";
+var LocalStorage = /** @class */ (function () {
+    function LocalStorage() {
+    }
+    /**
+     * Used in BluxClient initialization to dedupe local storage.
+     */
+    LocalStorage.getLogLevel = function () {
+        return localStorage.getItem(BlUX_LOGLEVEL);
+    };
+    LocalStorage.setLogLevel = function (loglevel) {
+        localStorage.setItem(BlUX_LOGLEVEL, loglevel);
+    };
+    LocalStorage.getBluxId = function () {
+        var bluxId = localStorage.getItem(BLUX_ID);
+        return bluxId === "undefined" || (bluxId === null || bluxId === void 0 ? void 0 : bluxId.trim()) == "" ? null : bluxId;
+    };
+    LocalStorage.setBluxId = function (bluxId) {
+        localStorage.setItem(BLUX_ID, bluxId);
+    };
+    LocalStorage.getDeviceId = function () {
+        var deviceId = localStorage.getItem(BLUX_DEVICE_ID);
+        return deviceId === "undefined" || (deviceId === null || deviceId === void 0 ? void 0 : deviceId.trim()) == "" ? null : deviceId;
+    };
+    LocalStorage.setDeviceId = function (deviceId) {
+        localStorage.setItem(BLUX_DEVICE_ID, deviceId);
+    };
+    LocalStorage.getUserId = function () {
+        var userId = localStorage.getItem(BLUX_USER_ID);
+        return userId === "undefined" || (userId === null || userId === void 0 ? void 0 : userId.trim()) == "" ? null : userId;
+    };
+    LocalStorage.setUserId = function (userId) {
+        localStorage.setItem(BLUX_USER_ID, userId);
+    };
+    return LocalStorage;
+}());
+exports.LocalStorage = LocalStorage;

package/dist/core/Logger.d.ts

@@ -0,0 +1,14 @@
+type ConsoleLog = (message?: unknown, ...optionalParams: unknown[]) => void;
+export declare class Logger {
+    static debug: ConsoleLog;
+    static trace: ConsoleLog;
+    static info: ConsoleLog;
+    static warn: ConsoleLog;
+    static error: ConsoleLog;
+    private static proxyMethodsCreated?;
+    private static shouldLog;
+    static setLevel(level: string): void;
+    private static wrapWithPrefix;
+    static createProxyMethods(): void;
+}
+export {};

package/dist/core/Logger.js

@@ -0,0 +1,90 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+exports.__esModule = true;
+exports.Logger = void 0;
+var LocalStorage_1 = require("./LocalStorage");
+var Logger = /** @class */ (function () {
+    function Logger() {
+    }
+    Logger.shouldLog = function () {
+        try {
+            if (typeof window === "undefined" || typeof window.localStorage === "undefined") {
+                return false;
+            }
+            var level = LocalStorage_1.LocalStorage.getLogLevel();
+            if (level && level.toLowerCase() === "trace") {
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        catch (e) {
+            /* LocalStorage may not be accessible on browser profiles that restrict 3rd party cookies */
+            return false;
+        }
+    };
+    Logger.setLevel = function (level) {
+        if (typeof window === "undefined" || typeof window.localStorage === "undefined") {
+            return;
+        }
+        try {
+            LocalStorage_1.LocalStorage.setLogLevel(level);
+            Logger.proxyMethodsCreated = undefined;
+            Logger.createProxyMethods();
+        }
+        catch (e) {
+            /* LocalStorage may not be accessible on browser profiles that restrict 3rd party cookies */
+            return;
+        }
+    };
+    Logger.wrapWithPrefix = function (method) {
+        return function (message) {
+            var optionalParams = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                optionalParams[_i - 1] = arguments[_i];
+            }
+            method.apply(void 0, __spreadArray(["[BluxClient] ".concat(message)], optionalParams, false));
+        };
+    };
+    Logger.createProxyMethods = function () {
+        if (typeof Logger.proxyMethodsCreated !== "undefined") {
+            return;
+        }
+        else {
+            Logger.proxyMethodsCreated = true;
+        }
+        var methods = {
+            log: "debug",
+            trace: "trace",
+            info: "info",
+            warn: "warn",
+            error: "error"
+        };
+        for (var _i = 0, _a = Object.keys(methods); _i < _a.length; _i++) {
+            var nativeMethod = _a[_i];
+            var nativeMethodExists = typeof console[nativeMethod] !== "undefined";
+            var methodToMapTo = methods[nativeMethod];
+            var shouldMap = nativeMethodExists && (Logger.shouldLog() || methodToMapTo === "error");
+            if (shouldMap) {
+                Logger[methodToMapTo] = Logger.wrapWithPrefix(console[nativeMethod].bind(console));
+            }
+            else {
+                // We want to skip logging, so this is internally an empty function.
+                // eslint-disable-next-line @typescript-eslint/no-empty-function
+                Logger[methodToMapTo] = function () { };
+            }
+        }
+    };
+    return Logger;
+}());
+exports.Logger = Logger;
+Logger.createProxyMethods();

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import BluxClient from "./BluxClient";
+import { AddProductDetailViewEvent, AddLikeEvent, AddCartaddEvent, AddPurchaseEvent, AddPageViewEvent, AddRateEvent, AddRecommendationViewEvent, AddCustomEvent, UpdateUserProperties } from "./requests";
+export { AddProductDetailViewEvent, AddLikeEvent, AddCartaddEvent, AddPurchaseEvent, AddRateEvent, AddPageViewEvent, AddRecommendationViewEvent, AddCustomEvent, UpdateUserProperties, };
+export default BluxClient;

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.UpdateUserProperties = exports.AddCustomEvent = exports.AddRecommendationViewEvent = exports.AddPageViewEvent = exports.AddRateEvent = exports.AddPurchaseEvent = exports.AddCartaddEvent = exports.AddLikeEvent = exports.AddProductDetailViewEvent = void 0;
+var BluxClient_1 = __importDefault(require("./BluxClient"));
+var requests_1 = require("./requests");
+exports.AddProductDetailViewEvent = requests_1.AddProductDetailViewEvent;
+exports.AddLikeEvent = requests_1.AddLikeEvent;
+exports.AddCartaddEvent = requests_1.AddCartaddEvent;
+exports.AddPurchaseEvent = requests_1.AddPurchaseEvent;
+exports.AddPageViewEvent = requests_1.AddPageViewEvent;
+exports.AddRateEvent = requests_1.AddRateEvent;
+exports.AddRecommendationViewEvent = requests_1.AddRecommendationViewEvent;
+exports.AddCustomEvent = requests_1.AddCustomEvent;
+exports.UpdateUserProperties = requests_1.UpdateUserProperties;
+exports["default"] = BluxClient_1["default"];

package/dist/requests/Devices/ActivateDevice.d.ts

@@ -0,0 +1,8 @@
+import { Request } from "../Request";
+export declare class ActivateDevice extends Request {
+    protected bluxId: string;
+    protected deviceId: string;
+    protected lastActiveAt: string | null;
+    constructor(bluxId: string, deviceId: string);
+    getPayload(): object;
+}

package/dist/requests/Devices/ActivateDevice.js

@@ -0,0 +1,39 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+exports.ActivateDevice = void 0;
+var Request_1 = require("../Request");
+var ActivateDevice = /** @class */ (function (_super) {
+    __extends(ActivateDevice, _super);
+    function ActivateDevice(bluxId, deviceId) {
+        var _this = _super.call(this, "PATCH", "/devices") || this;
+        _this.bluxId = bluxId;
+        _this.deviceId = deviceId;
+        _this.lastActiveAt = new Date().toISOString();
+        return _this;
+    }
+    ActivateDevice.prototype.getPayload = function () {
+        var payload = {
+            blux_id: this.bluxId,
+            device_id: this.deviceId,
+            last_active_at: this.lastActiveAt
+        };
+        return payload;
+    };
+    return ActivateDevice;
+}(Request_1.Request));
+exports.ActivateDevice = ActivateDevice;

package/dist/requests/Devices/CreateDevice.d.ts

@@ -0,0 +1,14 @@
+import { Request } from "../Request";
+export declare class CreateDevice extends Request {
+    protected platform: string | null;
+    protected deviceModel: string | null;
+    protected osVersion: string | null;
+    protected sdkVersion: string | null;
+    protected sdkType: string | null;
+    protected timezone: string | null;
+    protected languageCode: string | null;
+    protected countryCode: string | null;
+    protected lastActiveAt: string | null;
+    constructor();
+    getPayload(): object;
+}

package/dist/requests/Devices/CreateDevice.js

@@ -0,0 +1,54 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+exports.CreateDevice = void 0;
+var BluxClient_1 = __importDefault(require("../../BluxClient"));
+var Request_1 = require("../Request");
+var CreateDevice = /** @class */ (function (_super) {
+    __extends(CreateDevice, _super);
+    function CreateDevice() {
+        var _this = _super.call(this, "POST", "/devices") || this;
+        _this.platform = "typescript";
+        _this.deviceModel = navigator.userAgent; // 기기 모델;
+        _this.osVersion = navigator.userAgent; // OS 버전 (navigator.userAgent를 통해 확인);
+        _this.sdkVersion = BluxClient_1["default"].sdkInfo.version;
+        _this.sdkType = BluxClient_1["default"].sdkInfo.type;
+        _this.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        _this.languageCode = navigator.language.split("-")[0];
+        _this.countryCode = navigator.language.split("-")[1];
+        _this.lastActiveAt = new Date().toISOString();
+        return _this;
+    }
+    CreateDevice.prototype.getPayload = function () {
+        return {
+            platform: this.platform,
+            device_model: this.deviceModel,
+            os_version: this.osVersion,
+            sdk_version: this.sdkVersion,
+            sdk_type: this.sdkType,
+            timezone: this.timezone,
+            language_code: this.languageCode,
+            country_code: this.countryCode,
+            last_active_at: this.lastActiveAt
+        };
+    };
+    return CreateDevice;
+}(Request_1.Request));
+exports.CreateDevice = CreateDevice;

package/dist/requests/Devices/UpdateDevice.d.ts

@@ -0,0 +1,17 @@
+import { Request } from "../Request";
+export declare class UpdateDevice extends Request {
+    protected bluxId: string;
+    protected deviceId: string;
+    protected userId?: string | null;
+    protected platform: string | null;
+    protected deviceModel: string | null;
+    protected osVersion: string | null;
+    protected sdkVersion: string | null;
+    protected sdkType: string | null;
+    protected timezone: string | null;
+    protected languageCode: string | null;
+    protected countryCode: string | null;
+    protected lastActiveAt: string | null;
+    constructor(bluxId: string, deviceId: string, userId?: string | null);
+    getPayload(): object;
+}