sk-front-lib 0.17.48 → 0.17.49

package/fesm2020/sk-front-lib-crud.mjs

@@ -0,0 +1,1525 @@
+import * as i0 from '@angular/core';
+import { Injectable, PLATFORM_ID, Inject } from '@angular/core';
+import { map, tap, catchError, switchMap, take } from 'rxjs/operators';
+import * as i1 from 'sk-front-lib/api';
+import { ApiPageableParam } from 'sk-front-lib/api';
+import { SkFile, SkUser, SkDocument, SkBoard, SkProduct, SkPromotion, SkCart, SkOrderDetail, SkPoint, SkDocumentCommentParent, SkStore } from 'sk-front-lib/model';
+import { BehaviorSubject, of } from 'rxjs';
+import * as i2 from '@angular/router';
+import { HttpParams } from '@angular/common/http';
+import { SkUtils } from 'sk-front-lib';
+import { isPlatformBrowser } from '@angular/common';
+
+class SkAffiliateService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    registerAffiliate(data) {
+        return this._apiService.post(`/api/public/affiliate`, data).pipe(map(response => response.data));
+    }
+    getMyAffiliateData() {
+        return this._apiService.get(`/api/public/affiliate/me`).pipe(map(response => response.data));
+    }
+    getMyAffiliateStats() {
+        return this._apiService.get(`/api/public/affiliate/me/stats`).pipe(map(response => response.data));
+    }
+    getAdminAffiliateStats(id) {
+        return this._apiService.get(`/api/admin/affiliate/user-id/${id}/stats`).pipe(map(response => response.data));
+    }
+    productViewEvent(productId, affiliateKey) {
+        return this._apiService.get(`/api/public/affiliate/event/product-view?id=${productId}&affiliate=${affiliateKey}`).pipe(map(response => response.data));
+    }
+    getAdminList(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/affiliate`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getAdminAffiliate(id) {
+        return this._apiService.get(`/api/admin/affiliate/${id}`).pipe(map(response => response.data));
+    }
+    getAdminAffiliateByUserId(userId) {
+        return this._apiService.get(`/api/admin/affiliate/user-id/${userId}`).pipe(map(response => response.data));
+    }
+    updateAdminStatus(id, data) {
+        return this._apiService.put(`/api/admin/affiliate/${id}/update-status`, data).pipe(map(response => response.data));
+    }
+    activateAdminAffiliates(affiliates) {
+        return this._apiService.put(`/api/admin/affiliate/activate/${affiliates.map(i => i.id).join(',')}`, null);
+    }
+    deactivateAdminAffiliates(affiliates) {
+        return this._apiService.put(`/api/admin/affiliate/deactivate/${affiliates.map(i => i.id).join(',')}`, null);
+    }
+    deleteAffiliates(affiliates) {
+        return this._apiService.delete(`/api/admin/affiliate/delete/${affiliates.map(i => i.id).join(',')}`);
+    }
+    getAdminAffiliateTargets(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/affiliate/targets`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getAdminAffiliateTarget(id) {
+        return this._apiService.get(`/api/admin/affiliate/targets/${id}`).pipe(map(response => response.data));
+    }
+    createAdminAffiliateTarget(data) {
+        return this._apiService.post(`/api/admin/affiliate/targets`, {
+            type: data.type,
+            apply: data.apply,
+            orderIndex: data.orderIndex,
+            startDate: data.startDate,
+            endDate: data.endDate,
+            brand: data.brand?.id,
+            category: data.category?.id,
+            products: (data.products || []).map(i => i.id),
+            rebateAmount: data.rebateAmount,
+            rebateType: data.rebateType,
+            activated: data.activated
+        }).pipe(map(response => response.data));
+    }
+    updateAdminAffiliateTarget(id, data) {
+        return this._apiService.put(`/api/admin/affiliate/targets/${id}`, {
+            type: data.type,
+            apply: data.apply,
+            orderIndex: data.orderIndex,
+            startDate: data.startDate,
+            endDate: data.endDate,
+            brand: data.brand?.id,
+            category: data.category?.id,
+            products: (data.products || []).map(i => i.id),
+            rebateAmount: data.rebateAmount,
+            rebateType: data.rebateType,
+            activated: data.activated
+        }).pipe(map(response => response.data));
+    }
+    deleteAdminAffiliateTargets(target = []) {
+        return this._apiService.delete(`/api/admin/affiliate/targets/${target.map(i => i.id).join(',')}`);
+    }
+}
+SkAffiliateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkAffiliateService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkAffiliateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkAffiliateService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkAffiliateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkFileService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+        this.apiServer = _apiService.apiServer;
+    }
+    getFile(id) {
+        return this._apiService.get(`/api/admin/files/${id}`)
+            .pipe(map(result => new SkFile(result.data)));
+    }
+    getAdminFiles(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/files`, params.buildHttpParams()).pipe(map(response => {
+            response.data.content = (response.data.content || []).map(item => new SkFile(item));
+            return response.data;
+        }));
+    }
+    deleteAdminFile(id) {
+        return this._apiService.delete(`/api/admin/files/${id}`);
+    }
+    updateAdminFile(id, data) {
+        return this._apiService.put(`/api/admin/files/${id}`, data).pipe(map(result => new SkFile(result.data)));
+    }
+}
+SkFileService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkFileService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkFileService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkFileService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkFileService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkAuthService {
+    constructor(_router, apiService) {
+        this._router = _router;
+        this.apiService = apiService;
+        this.baseUrl = '/api/auth';
+        this._userinfo$ = new BehaviorSubject(new SkUser());
+    }
+    get userinfo$() {
+        return this._userinfo$.asObservable();
+    }
+    moveLoginPage() {
+        return this._router.navigate([this.apiService.loginUrl, { returnUrl: this._router.url }]);
+    }
+    login(data) {
+        return this.apiService.post(this.baseUrl + '/signin', data).pipe(tap(response => {
+            if (response.status === 200) {
+                this.apiService.setToken(response.data.token);
+            }
+        }), map(response => response.data));
+    }
+    logout() {
+        this._userinfo$.next(new SkUser());
+        this.apiService.clearToken();
+    }
+    loadMyInfo(refresh = false) {
+        if (this.apiService.getToken()) {
+            if (this._userinfo$.getValue().isAnonymous() || refresh) {
+                return this.apiService.get(this.baseUrl + '/me').pipe(map(result => !!result.data ? new SkUser(result.data) : new SkUser()), catchError(err => of(new SkUser())), tap(user => this._userinfo$.next(user)), switchMap(() => of(this._userinfo$.getValue())));
+            }
+        }
+        return of(this._userinfo$.getValue());
+    }
+    checkAdminAccessable() {
+        return this.loadMyInfo().pipe(map(result => result.isAdminAccessable()));
+    }
+    checkLogin() {
+        return this.loadMyInfo().pipe(map(result => !result.isAnonymous()));
+    }
+    sendMailForActivateAccount(email) {
+        return this.apiService.post(this.baseUrl + '/activate-account', { email }).pipe(map(response => response.data));
+    }
+    sendMailForResetPassword(email) {
+        return this.apiService.post(this.baseUrl + '/reset-password', { email }).pipe(map(response => response.data));
+    }
+    requestActivateAccount(data) {
+        return this.apiService.post(this.baseUrl + '/activate-account-complete', data).pipe(map(response => response.data));
+    }
+    updatePassword(data) {
+        return this.apiService.post(this.baseUrl + '/update-password', data).pipe(map(response => response.data));
+    }
+}
+SkAuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkAuthService, deps: [{ token: i2.Router }, { token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkAuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkAuthService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkAuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i2.Router }, { type: i1.SkApiService }]; } });
+
+class SkAuthGuard {
+    constructor(authService, router) {
+        this.authService = authService;
+        this.router = router;
+    }
+    canActivate(route, state) {
+        return this.authService.checkLogin()
+            .pipe(tap(logged => {
+            if (!logged) {
+                this.router.navigate(['/login', { returnUrl: state.url }]);
+            }
+        }));
+    }
+    canActivateChild(route, state) {
+        return this.canActivate(route, state);
+    }
+}
+SkAuthGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkAuthGuard, deps: [{ token: SkAuthService }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+SkAuthGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkAuthGuard, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkAuthGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: SkAuthService }, { type: i2.Router }]; } });
+
+class SkAuthAdminGuard {
+    constructor(authService, router) {
+        this.authService = authService;
+        this.router = router;
+    }
+    canActivate(route, state) {
+        return this.authService.checkAdminAccessable()
+            .pipe(tap(logged => {
+            if (!logged) {
+                this.router.navigate(['/login', { returnUrl: state.url }]);
+            }
+        }));
+    }
+    canActivateChild(route, state) {
+        return this.canActivate(route, state);
+    }
+}
+SkAuthAdminGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkAuthAdminGuard, deps: [{ token: SkAuthService }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+SkAuthAdminGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkAuthAdminGuard, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkAuthAdminGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: SkAuthService }, { type: i2.Router }]; } });
+
+class SkUserService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    getUser(id) {
+        return this._apiService.get(`/api/public/users/${id}`).pipe(map(response => new SkUser(response.data)));
+    }
+    getAdminUser(id) {
+        return this._apiService.get(`/api/admin/users/${id}`).pipe(map(response => new SkUser(response.data)));
+    }
+    getAdminUserByEmail(email) {
+        return this._apiService.get(`/api/admin/users/email/${email}`).pipe(map(response => new SkUser(response.data)));
+    }
+    getUsers(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/public/users`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getAdminUsers(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/users`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    createAdminUser(data) {
+        return this._apiService.post(`/api/admin/users`, data).pipe(map(response => new SkUser(response.data)));
+    }
+    updateUser(data) {
+        return this._apiService.put(`/api/public/users/me`, data).pipe(map(response => new SkUser(response.data)));
+    }
+    updateAdminUser(id, data) {
+        return this._apiService.put(`/api/admin/users/${id}`, data).pipe(map(response => new SkUser(response.data)));
+    }
+    activateAdminUsers(users) {
+        return this._apiService.put(`/api/admin/users/activate/${users.map(user => user.id).join(',')}`, null);
+    }
+    deactivateAdminUsers(users) {
+        return this._apiService.put(`/api/admin/users/deactivate/${users.map(user => user.id).join(',')}`, null);
+    }
+    deleteAdminUsers(users) {
+        return this._apiService.delete(`/api/admin/users/delete/${users.map(user => user.id).join(',')}`);
+    }
+    getAdminUsersCount() {
+        return this._apiService.get('/api/admin/users/count')
+            .pipe(map(response => response.data));
+    }
+    signup(data) {
+        return this._apiService.post('/api/auth/signup', data)
+            .pipe(tap(response => {
+            if (response.status === 200) {
+                this._apiService.setToken(response.data.token);
+            }
+        }), map(response => response.data));
+    }
+    leave() {
+        return this._apiService.put('/api/auth/leave', {})
+            .pipe(map(response => response.data));
+    }
+    isEmailExists(email) {
+        return this._apiService.get('/api/public/users/exists/email', new HttpParams().append('email', email)).pipe(map(response => response.data));
+    }
+}
+SkUserService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkUserService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkUserService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkUserService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkUserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkDocumentService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    getDocument(id) {
+        return this._apiService.get(`/api/public/documents/${id}`).pipe(map(response => new SkDocument(response.data)));
+    }
+    getDocumentByUrl(url) {
+        return this._apiService.get(`/api/public/documents/url/${url}`).pipe(map(response => new SkDocument(response.data)));
+    }
+    getAdminDocument(id) {
+        return this._apiService.get(`/api/admin/documents/${id}`).pipe(map(response => new SkDocument(response.data)));
+    }
+    getDocumentProduct(id) {
+        return this._apiService.get(`/api/public/documents/${id}/product`).pipe(map(response => response.data));
+    }
+    getAdminDocumentProduct(id) {
+        return this._apiService.get(`/api/admin/documents/${id}/product`).pipe(map(response => response.data));
+    }
+    getDocuments(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/public/documents`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getAdminDocuments(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/documents`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getDocumentsArray(ids) {
+        return this._apiService.get(`/api/public/documents/array/${ids.join(',')}`).pipe(map(response => response.data));
+    }
+    getAdminDocumentsArray(ids) {
+        return this._apiService.get(`/api/admin/documents/array/${ids.join(',')}`).pipe(map(response => response.data));
+    }
+    createAdminDocument(data) {
+        return this._apiService.post(`/api/admin/documents`, data).pipe(map(response => new SkDocument(response.data)));
+    }
+    copyAdminDocument(id) {
+        return this._apiService.post(`/api/admin/documents/${id}/copy`, {}).pipe(map(response => new SkDocument(response.data)));
+    }
+    writePost(data) {
+        return this._apiService.post(`/api/public/documents`, data).pipe(map(response => response.data));
+    }
+    deletePost(id) {
+        return this._apiService.delete(`/api/public/documents/${id}`).pipe(map(response => response.data));
+    }
+    updateDocument(id, data) {
+        return this._apiService.put(`/api/public/documents/${id}`, data).pipe(map(response => new SkDocument(response.data)));
+    }
+    updateAdminDocument(id, data) {
+        return this._apiService.put(`/api/admin/documents/${id}`, data).pipe(map(response => new SkDocument(response.data)));
+    }
+    updateAdminDocumentArticle(id, data) {
+        return this._apiService.put(`/api/admin/documents/${id}/article`, data).pipe(map(response => new SkDocument(response.data)));
+    }
+    updateAdminDocumentImage(id, data) {
+        return this._apiService.put(`/api/admin/documents/${id}/image`, data).pipe(map(response => new SkDocument(response.data)));
+    }
+    updateAdminDocumentProduct(id, data) {
+        return this._apiService.put(`/api/admin/documents/${id}/product`, data).pipe(map(response => response.data));
+    }
+    updateAdminDocumentOpengraph(id, data) {
+        return this._apiService.put(`/api/admin/documents/${id}/opengraph`, data).pipe(map(response => new SkDocument(response.data)));
+    }
+    activateAdminDocuments(documents) {
+        return this._apiService.put(`/api/admin/documents/activate/${documents.map(document => document.id).join(',')}`, null);
+    }
+    deactivateAdminDocuments(documents) {
+        return this._apiService.put(`/api/admin/documents/deactivate/${documents.map(document => document.id).join(',')}`, null);
+    }
+    deleteAdminDocuments(documents) {
+        return this._apiService.delete(`/api/admin/documents/delete/${documents.map(document => document.id).join(',')}`);
+    }
+    getAdminDocumentsCount() {
+        return this._apiService.get('/api/admin/documents/count')
+            .pipe(map(response => response.data));
+    }
+    getNextDocumentId(id) {
+        return this._apiService.get(`/api/public/documents/${id}/next`)
+            .pipe(map(response => response.data));
+    }
+    getPrevDocumentId(id) {
+        return this._apiService.get(`/api/public/documents/${id}/prev`)
+            .pipe(map(response => response.data));
+    }
+    getAdminPublish(documentId) {
+        return this._apiService.get(`/api/admin/documents/${documentId}/publish`).pipe(map(response => response.data));
+    }
+    deleteAdminPublish(documentId, id) {
+        return this._apiService.delete(`/api/admin/documents/${documentId}/publish/${id}`).pipe(map(response => response.data));
+    }
+    createAdminPublish(documentId, data) {
+        return this._apiService.post(`/api/admin/documents/${documentId}/publish`, data).pipe(map(response => response.data));
+    }
+    updateAdminPublish(documentId, data) {
+        return this._apiService.put(`/api/admin/documents/${documentId}/publish`, data).pipe(map(response => response.data));
+    }
+}
+SkDocumentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkDocumentService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkDocumentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkDocumentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkDocumentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkBoardService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    getBoard(url, params = new ApiPageableParam()) {
+        return this._apiService.get(`/api/public/boards/${url}`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getAdminBoard(id) {
+        return this._apiService.get(`/api/admin/boards/${id}`).pipe(map(response => new SkBoard(response.data)));
+    }
+    getBoards(showSupport = false) {
+        return this._apiService.get(`/api/public/boards`, new HttpParams().append('showSupport', String(showSupport))).pipe(map(response => response.data));
+    }
+    getAdminBoards(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/boards`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    createAdminBoard(data) {
+        return this._apiService.post(`/api/admin/boards`, data).pipe(map(response => new SkBoard(response.data)));
+    }
+    updateBoard(id, data) {
+        return this._apiService.put(`/api/public/boards/${id}`, data).pipe(map(response => new SkBoard(response.data)));
+    }
+    updateAdminBoard(id, data) {
+        return this._apiService.put(`/api/admin/boards/${id}`, data).pipe(map(response => new SkBoard(response.data)));
+    }
+    getAllNoticeDocuments() {
+        return this._apiService.get(`/api/public/boards/notices`).pipe(map(response => (response.data || [])));
+    }
+    activateAdminBoards(boards) {
+        return this._apiService.put(`/api/admin/boards/activate/${boards.map(board => board.id).join(',')}`, null);
+    }
+    deactivateAdminBoards(boards) {
+        return this._apiService.put(`/api/admin/boards/deactivate/${boards.map(board => board.id).join(',')}`, null);
+    }
+    deleteAdminBoards(boards) {
+        return this._apiService.delete(`/api/admin/boards/delete/${boards.map(board => board.id).join(',')}`);
+    }
+}
+SkBoardService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkBoardService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkBoardService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkBoardService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkBoardService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkBrandService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    getBrand(id) {
+        return this._apiService.get(`/api/public/brands/${id}`).pipe(map(response => response.data));
+    }
+    getAdminBrand(id) {
+        return this._apiService.get(`/api/admin/brands/${id}`).pipe(map(response => response.data));
+    }
+    getBrands(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/public/brands`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getAllBrands(params = new ApiPageableParam()) {
+        return this._apiService.get(`/api/public/brands/all`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getAdminBrands(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/brands`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getAdminAllBrands() {
+        return this._apiService.get(`/api/admin/brands/all`).pipe(map(response => response.data));
+    }
+    createAdminBrand(data) {
+        return this._apiService.post(`/api/admin/brands`, data).pipe(map(response => response.data));
+    }
+    updateAdminBrand(id, data) {
+        return this._apiService.put(`/api/admin/brands/${id}`, data).pipe(map(response => response.data));
+    }
+    deleteAdminBrands(brands) {
+        return this._apiService.delete(`/api/admin/brands/delete/${brands.map(brand => brand.id).join(',')}`);
+    }
+}
+SkBrandService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkBrandService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkBrandService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkBrandService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkBrandService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkCategoryService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    getCategory(id) {
+        return this._apiService.get(`/api/public/categories/${id}`).pipe(map(response => response.data));
+    }
+    getAdminCategory(id) {
+        return this._apiService.get(`/api/admin/categories/${id}`).pipe(map(response => response.data));
+    }
+    getCategories(type) {
+        return this._apiService.get(`/api/public/categories`).pipe(map(response => response.data.filter(item => item.type === type)));
+    }
+    getAdminAllCategories() {
+        return this._apiService.get(`/api/admin/categories/all`).pipe(map(response => response.data));
+    }
+    getAdminCategories(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/categories`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getAdminSsubCategoryItems(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/categories/subitems`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getAdminCategoriesDetail(idArray) {
+        return this._apiService.get(`/api/admin/categories/detail/${idArray.join(',')}`).pipe(map(response => (response.data || []).map(value => {
+            return Object.assign({}, { subCategories: [] }, value);
+        })));
+    }
+    createAdminCategory(data) {
+        return this._apiService.post(`/api/admin/categories`, data).pipe(map(response => response.data));
+    }
+    updateAdminCategory(id, data) {
+        return this._apiService.put(`/api/admin/categories/${id}`, data).pipe(map(response => response.data));
+    }
+    deleteAdminCategories(categories) {
+        return this._apiService.delete(`/api/admin/categories/delete/${categories.map(category => category.id).join(',')}`);
+    }
+    createAdminSubCategory(categoryId, data) {
+        return this._apiService.post(`/api/admin/categories/${categoryId}/sub`, data).pipe(map(response => response.data));
+    }
+    createAdminSubCategoryItem(categoryId, subCategoryId, data) {
+        return this._apiService.post(`/api/admin/categories/${categoryId}/sub/${subCategoryId}`, data).pipe(map(response => response.data));
+    }
+    deleteAdminSubCategory(categoryId, subCategoryId) {
+        return this._apiService.delete(`/api/admin/categories/${categoryId}/sub/${subCategoryId}`).pipe(map(response => response.data));
+    }
+    deleteAdminSubCategoryItem(categoryId, subCategoryId, subCategoryItemId) {
+        return this._apiService.delete(`/api/admin/categories/${categoryId}/sub/${subCategoryId}/${subCategoryItemId}`).pipe(map(response => response.data));
+    }
+}
+SkCategoryService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCategoryService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkCategoryService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCategoryService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCategoryService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkProductService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    getProduct(url) {
+        return this._apiService.get(`/api/public/products/${url}`).pipe(map(response => response.data));
+    }
+    getAdminProduct(id) {
+        return this._apiService.get(`/api/admin/products/${id}`).pipe(map(response => new SkProduct(response.data)));
+    }
+    getProducts(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/public/products`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getAdminProducts(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/products`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getProductsArray(ids) {
+        return this._apiService.get(`/api/public/products/array/${ids.join(',')}`).pipe(map(response => response.data));
+    }
+    getAdminProductsArray(ids) {
+        return this._apiService.get(`/api/admin/products/array/${ids.join(',')}`).pipe(map(response => response.data));
+    }
+    createAdminProduct(data) {
+        return this._apiService.post(`/api/admin/products`, data).pipe(map(response => new SkProduct(response.data)));
+    }
+    copyAdminProduct(id) {
+        return this._apiService.post(`/api/admin/products/${id}/copy`, {}).pipe(map(response => new SkProduct(response.data)));
+    }
+    updateProduct(id, data) {
+        return this._apiService.put(`/api/public/products/${id}`, data).pipe(map(response => new SkProduct(response.data)));
+    }
+    updateAdminProduct(id, data) {
+        return this._apiService.put(`/api/admin/products/${id}`, data).pipe(map(response => new SkProduct(response.data)));
+    }
+    updateAdminProductPrice(id, data) {
+        return this._apiService.put(`/api/admin/products/${id}/price`, data).pipe(map(response => new SkProduct(response.data)));
+    }
+    updateAdminProductOpengraph(id, data) {
+        return this._apiService.put(`/api/admin/products/${id}/opengraph`, data).pipe(map(response => new SkProduct(response.data)));
+    }
+    updateAdminProductNaverEP(id, data) {
+        return this._apiService.put(`/api/admin/products/${id}/naverep`, data).pipe(map(response => new SkProduct(response.data)));
+    }
+    updateAdminProductCatalog(id, data) {
+        return this._apiService.put(`/api/admin/products/${id}/catalog`, data).pipe(map(response => new SkProduct(response.data)));
+    }
+    updateAdminProductOption(id, data) {
+        return this._apiService.put(`/api/admin/products/${id}/option`, data).pipe(map(response => new SkProduct(response.data)));
+    }
+    updateAdminProductPackage(id, data) {
+        return this._apiService.put(`/api/admin/products/${id}/package`, data).pipe(map(response => new SkProduct(response.data)));
+    }
+    getAdminPackageChildrenOptions(id) {
+        return this._apiService.get(`/api/admin/products/${id}/package/children-options`).pipe(map(response => response.data));
+    }
+    getAdminPackageChildrenImages(id) {
+        return this._apiService.get(`/api/admin/products/${id}/package/children-images`).pipe(map(response => (response.data || []).map(item => new SkFile(item))));
+    }
+    updateAdminProductArticleDesc(id, data) {
+        return this._apiService.put(`/api/admin/products/${id}/article-desc`, data).pipe(map(response => new SkProduct(response.data)));
+    }
+    updateAdminProductArticleSpec(id, data) {
+        return this._apiService.put(`/api/admin/products/${id}/article-spec`, data).pipe(map(response => new SkProduct(response.data)));
+    }
+    updateAdminProductImage(id, data) {
+        return this._apiService.put(`/api/admin/products/${id}/image`, data).pipe(map(response => new SkProduct(response.data)));
+    }
+    updateAdminProductEDelivery(id, data) {
+        return this._apiService.put(`/api/admin/products/${id}/edelivery`, data).pipe(map(response => new SkProduct(response.data)));
+    }
+    updateAdminProductFurnitureDelivery(id, data) {
+        return this._apiService.put(`/api/admin/products/${id}/furniture-delivery`, data).pipe(map(response => new SkProduct(response.data)));
+    }
+    activateAdminProducts(products) {
+        return this._apiService.put(`/api/admin/products/activate/${products.map(product => product.id).join(',')}`, null);
+    }
+    deactivateAdminProducts(products) {
+        return this._apiService.put(`/api/admin/products/deactivate/${products.map(product => product.id).join(',')}`, null);
+    }
+    deleteAdminProducts(products) {
+        return this._apiService.delete(`/api/admin/products/delete/${products.map(product => product.id).join(',')}`);
+    }
+    getAdminProductsCount() {
+        return this._apiService.get('/api/admin/products/count')
+            .pipe(map(response => response.data));
+    }
+    updateWishlist(id) {
+        return this._apiService.put(`/api/public/products/${id}/wishlist`, {}).pipe(map(response => response.data));
+    }
+    getWishlist(id) {
+        return this._apiService.get(`/api/public/products/${id}/wishlist`).pipe(map(response => response.data));
+    }
+    getProductOptions(id) {
+        return this._apiService.get(`/api/public/products/${id}/options`).pipe(map(response => response.data));
+    }
+    getAdminProductSubCategoryItem(id) {
+        return this._apiService.get(`/api/admin/products/${id}/categories`).pipe(map(response => response.data || []));
+    }
+    updateAdminProductSubCategoryItems(id, idArr) {
+        return this._apiService.put(`/api/admin/products/${id}/categories`, { subCategoryItems: idArr }).pipe(map(response => response.data || []));
+    }
+    getProductsFilterData(params = new ApiPageableParam()) {
+        return this._apiService.get(`/api/public/products/filter-data`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getIncludedPackages(id) {
+        return this._apiService.get(`/api/public/products/${id}/included-packages`).pipe(map(response => response.data || []));
+    }
+    updateAdminStockConfig(id, data) {
+        return this._apiService.put(`/api/admin/products/${id}/stocks`, data).pipe(map(response => response.data));
+    }
+    getAdminStockCount(id) {
+        return this._apiService.get(`/api/admin/products/${id}/stocks/count`).pipe(map(response => Object.assign({ totalIn: 0, totalOut: 0, current: 0 }, response.data)));
+    }
+    getAdminStocks(id, params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/products/${id}/stocks`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    addAdminStock(id, data) {
+        return this._apiService.post(`/api/admin/products/${id}/stocks`, data).pipe(map(response => Object.assign({ totalIn: 0, totalOut: 0, current: 0 }, response.data)));
+    }
+    updateAdminStock(productId, stockId, data) {
+        return this._apiService.put(`/api/admin/products/${productId}/stocks/${stockId}`, data).pipe(map(response => response.data));
+    }
+    deleteAdminStock(productId, stockId) {
+        return this._apiService.delete(`/api/admin/products/${productId}/stocks/${stockId}`).pipe(map(response => response.data));
+    }
+    getAdminSeriesList(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/product-series`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getAdminSeries(id) {
+        return this._apiService.get(`/api/admin/product-series/${id}`).pipe(map(response => response.data));
+    }
+    createAdminSeries(data) {
+        return this._apiService.post(`/api/admin/product-series`, data).pipe(map(response => response.data));
+    }
+    updateAdminSeries(id, data) {
+        return this._apiService.put(`/api/admin/product-series/${id}`, data).pipe(map(response => response.data));
+    }
+    deleteAdminSeries(id) {
+        return this._apiService.delete(`/api/admin/product-series/${id}`).pipe(map(response => response.data));
+    }
+    getAdminPublish(productId) {
+        return this._apiService.get(`/api/admin/products/${productId}/publish`).pipe(map(response => response.data));
+    }
+    deleteAdminPublish(productId, id) {
+        return this._apiService.delete(`/api/admin/products/${productId}/publish/${id}`).pipe(map(response => response.data));
+    }
+    createAdminPublish(productId, data) {
+        return this._apiService.post(`/api/admin/products/${productId}/publish`, data).pipe(map(response => response.data));
+    }
+    updateAdminPublish(productId, data) {
+        return this._apiService.put(`/api/admin/products/${productId}/publish`, data).pipe(map(response => response.data));
+    }
+}
+SkProductService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkProductService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkProductService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkProductService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkProductService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkPromotionService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    getPromotion(id) {
+        return this._apiService.get(`/api/public/promotions/${id}`).pipe(map(response => response.data));
+    }
+    getPromotionPreview(id) {
+        return this._apiService.get(`/api/admin/promotions/${id}/preview`).pipe(map(response => response.data));
+    }
+    getAdminPromotion(id) {
+        return this._apiService.get(`/api/admin/promotions/${id}`).pipe(map(response => new SkPromotion(response.data)));
+    }
+    getAdminPromotionTarget(id) {
+        return this._apiService.get(`/api/admin/promotions/${id}/target`).pipe(map(response => response.data));
+    }
+    getPromotions(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/public/promotions`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getAdminPromotions(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/promotions`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getPromotionsArray(ids) {
+        return this._apiService.get(`/api/public/promotions/array/${ids.join(',')}`).pipe(map(response => response.data));
+    }
+    getAdminPromotionsArray(ids) {
+        return this._apiService.get(`/api/admin/promotions/array/${ids.join(',')}`).pipe(map(response => response.data));
+    }
+    createAdminPromotion(data) {
+        return this._apiService.post(`/api/admin/promotions`, data).pipe(map(response => new SkPromotion(response.data)));
+    }
+    updatePromotion(id, data) {
+        return this._apiService.put(`/api/public/promotions/${id}`, data).pipe(map(response => new SkPromotion(response.data)));
+    }
+    updateAdminPromotion(id, data) {
+        return this._apiService.put(`/api/admin/promotions/${id}`, data).pipe(map(response => new SkPromotion(response.data)));
+    }
+    updateAdminPromotionTarget(id, data) {
+        return this._apiService.put(`/api/admin/promotions/${id}/target`, data).pipe(map(response => response.data));
+    }
+    updateAdminPromotionGift(id, data) {
+        return this._apiService.put(`/api/admin/promotions/${id}/gift`, data).pipe(map(response => new SkPromotion(response.data)));
+    }
+    updateAdminPromotionContent(id, data) {
+        return this._apiService.put(`/api/admin/promotions/${id}/content`, data).pipe(map(response => new SkPromotion(response.data)));
+    }
+    updateAdminPromotionBenefit(id, data) {
+        return this._apiService.put(`/api/admin/promotions/${id}/benefit`, data).pipe(map(response => new SkPromotion(response.data)));
+    }
+    updateAdminPromotionImage(id, data) {
+        return this._apiService.put(`/api/admin/promotions/${id}/image`, data).pipe(map(response => new SkPromotion(response.data)));
+    }
+    updateAdminPromotionOpengraph(id, data) {
+        return this._apiService.put(`/api/admin/promotions/${id}/opengraph`, data).pipe(map(response => new SkPromotion(response.data)));
+    }
+    activateAdminPromotions(promotions) {
+        return this._apiService.put(`/api/admin/promotions/activate/${promotions.map(promotion => promotion.id).join(',')}`, null);
+    }
+    deactivateAdminPromotions(promotions) {
+        return this._apiService.put(`/api/admin/promotions/deactivate/${promotions.map(promotion => promotion.id).join(',')}`, null);
+    }
+    deleteAdminPromotions(promotions) {
+        return this._apiService.delete(`/api/admin/promotions/delete/${promotions.map(promotion => promotion.id).join(',')}`);
+    }
+    getAdminPromotionsCount() {
+        return this._apiService.get('/api/admin/promotions/count')
+            .pipe(map(response => response.data));
+    }
+}
+SkPromotionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkPromotionService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkPromotionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkPromotionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkPromotionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkConfigService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    getConfig(key, nullValue = null) {
+        return this._apiService.get(`/api/public/config/${key}`)
+            .pipe(map(result => result.data ? SkUtils.decodeBase64(result.data.value, nullValue) : nullValue));
+    }
+    setConfig(key, data, nullValue = []) {
+        return this._apiService.put(`/api/admin/config/${key}`, { value: SkUtils.encodeBase64(data) })
+            .pipe(map(result => result.data ? SkUtils.decodeBase64(result.data.value, nullValue) : nullValue));
+    }
+    getBankList() {
+        return this._apiService.get('/api/public/bank-list')
+            .pipe(map(result => result.data || []));
+    }
+}
+SkConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkConfigService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkConfigService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkCartApiService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    load() {
+        return this._apiService.get(`/api/public/carts`).pipe(map(response => (response.data || []).map(item => new SkCart(item))));
+    }
+    add(cart) {
+        const data = {
+            product: cart.product.id,
+            selectedOptions: cart.options.map(item => ({
+                value: item.value.id,
+                option: item.option.id,
+                amount: item.amount
+            })),
+            amount: cart.amount,
+            selectedGifts: (cart.gifts || []).map(item => ({ id: item.id }))
+        };
+        return this._apiService.post(`/api/public/carts`, data).pipe(map(response => (response.data || []).map(item => new SkCart(item))));
+    }
+    clear() {
+        return undefined;
+    }
+    remove(carts) {
+        return this.removeByIdArray(carts.map(cart => cart.id));
+    }
+    removeByIdArray(idArray) {
+        const ids = idArray.filter(id => Number(id) >= 1);
+        return this._apiService.delete(`/api/public/carts`, new HttpParams().append('target', ids.join(','))).pipe(map(response => (response.data || []).map(item => new SkCart(item))));
+    }
+    update(cart) {
+        return this._apiService.put(`/api/public/carts/${cart.id}`, { amount: cart.amount }).pipe(map(response => (response.data || []).map(item => new SkCart(item))));
+    }
+}
+SkCartApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCartApiService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkCartApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCartApiService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCartApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+class SkCartLocalService {
+    constructor(platformId) {
+        this.platformId = platformId;
+        this.isPlatformBrowser = isPlatformBrowser(this.platformId);
+    }
+    loadRaw() {
+        let data = [];
+        try {
+            if (this.isPlatformBrowser) {
+                data = (SkUtils.decodeBase64(localStorage.getItem('cartData')) || []).map(item => new SkCart(item));
+            }
+        }
+        catch (e) {
+            data = [];
+        }
+        return data;
+    }
+    load() {
+        return of(this.loadRaw());
+    }
+    add(cart) {
+        cart.id = Math.random();
+        const cartList = [cart, ...this.loadRaw()];
+        localStorage.setItem('cartData', SkUtils.encodeBase64(cartList));
+        return of(cartList);
+    }
+    clear() {
+        const cartList = [];
+        localStorage.setItem('cartData', SkUtils.encodeBase64(cartList));
+        return of(cartList);
+    }
+    remove(carts) {
+        return this.removeByIdArray(carts.map(cart => cart.id));
+    }
+    removeByIdArray(idArray) {
+        const removedItems = this.loadRaw().filter(item => idArray.findIndex(id => id === item.id) < 0);
+        localStorage.setItem('cartData', SkUtils.encodeBase64(removedItems));
+        return of(removedItems);
+    }
+    update(cart) {
+        const cartList = this.loadRaw();
+        const index = this.loadRaw().findIndex(item => item.id === cart.id);
+        if (index > -1) {
+            cartList[index] = cart;
+            localStorage.setItem('cartData', SkUtils.encodeBase64(cartList));
+        }
+        return of(cartList);
+    }
+}
+SkCartLocalService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCartLocalService, deps: [{ token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable });
+SkCartLocalService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCartLocalService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCartLocalService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; } });
+class SkCartService {
+    constructor(_authService, _apiService, _apiCartService, _apiLocalService) {
+        this._authService = _authService;
+        this._apiService = _apiService;
+        this._apiCartService = _apiCartService;
+        this._apiLocalService = _apiLocalService;
+        this._cartItems$ = new BehaviorSubject([]);
+        this.cartItems$ = this._cartItems$.asObservable();
+        this._selectedItems$ = new BehaviorSubject([]);
+        this.selectedItems$ = this._selectedItems$.asObservable();
+        // this._myInfoSubscription = this._authService.userinfo$.subscribe(() => {
+        //     this.load();
+        // });
+    }
+    get cartItems() {
+        return this._cartItems$.getValue();
+    }
+    set cartItems(value) {
+        this._cartItems$.next(value);
+    }
+    get selectedItems() {
+        return this._selectedItems$.getValue();
+    }
+    set selectedItems(value) {
+        this._selectedItems$.next(value);
+    }
+    load() {
+        this._authService.checkLogin()
+            .pipe(switchMap(result => result ? this._apiCartService.load() : this._apiLocalService.load()))
+            .subscribe(result => this._cartItems$.next(result));
+    }
+    clear() {
+        this._authService.checkLogin()
+            .pipe(switchMap(result => result ? this._apiCartService.clear() : this._apiLocalService.clear()))
+            .subscribe(result => this._cartItems$.next(result));
+    }
+    add(cart) {
+        return this._authService.checkLogin()
+            .pipe(switchMap(result => result ? this._apiCartService.add(cart) : this._apiLocalService.add(cart)), tap(result => this._cartItems$.next(result)));
+    }
+    remove(carts) {
+        this._authService.checkLogin()
+            .pipe(switchMap(result => result ? this._apiCartService.remove(carts) : this._apiLocalService.remove(carts)))
+            .subscribe(result => {
+            this._cartItems$.next(result);
+            this.checkSelectedItems();
+        });
+    }
+    removeByIdArray(idArray) {
+        this._authService.checkLogin()
+            .pipe(switchMap(result => result ? this._apiCartService.removeByIdArray(idArray) : this._apiLocalService.removeByIdArray(idArray)))
+            .subscribe(result => {
+            this._cartItems$.next(result);
+            this.checkSelectedItems();
+        });
+    }
+    update(cart) {
+        this._authService.checkLogin()
+            .pipe(switchMap(result => result ? this._apiCartService.update(cart) : this._apiLocalService.update(cart)))
+            .subscribe(result => this._cartItems$.next(result));
+    }
+    getCart(id) {
+        return this._cartItems$.getValue().find(value => value.id === id);
+    }
+    checkSelectedItems() {
+        this.selectedItems = this.selectedItems.filter(value => !!this.getCart(value));
+    }
+    selectAll() {
+        this.selectedItems = this._cartItems$.getValue().map(item => item.id);
+    }
+    deSelectAll() {
+        this.selectedItems = [];
+    }
+    toggleSelectAll() {
+        if (this.selectedItems.length === this._cartItems$.getValue().length) {
+            this.deSelectAll();
+        }
+        else {
+            this.selectAll();
+        }
+    }
+    toggleSelect(cart) {
+        const targetIndex = this.selectedItems.findIndex(item => item === cart.id);
+        if (targetIndex === -1) {
+            this.selectedItems = [...this.selectedItems, cart.id];
+        }
+        else {
+            const target = this.selectedItems;
+            target.splice(targetIndex, 1);
+            this.selectedItems = target;
+        }
+    }
+    isSelected(cart) {
+        return this.selectedItems.findIndex(item => item === cart.id) > -1;
+    }
+    isSelectedAll() {
+        return this.selectedItems.length > 0 && this.selectedItems.length === this._cartItems$.getValue().length;
+    }
+    isIntermediate() {
+        return this.selectedItems.length > 0 && this.selectedItems.length !== this._cartItems$.getValue().length;
+    }
+    createOrder(paymentType, affiliateKey) {
+        return this._authService.checkLogin()
+            .pipe(take(1), map(result => {
+            if (result) {
+                return {
+                    apiUrl: `/api/public/orders/from-cart`,
+                    items: this.selectedItems
+                };
+            }
+            else {
+                return {
+                    apiUrl: `/api/public/orders/from-data`,
+                    items: this.selectedItems
+                        .map(id => this.getCart(id))
+                        .map(cart => ({
+                        id: cart.id,
+                        productId: cart.product.id,
+                        amount: cart.amount,
+                        options: (cart.options || []).map(option => ({
+                            optionId: option.option.id,
+                            valueId: option.value.id,
+                            amount: option.amount || 1
+                        })),
+                        gifts: (cart.gifts || []).map(item => ({ id: item.id }))
+                    }))
+                };
+            }
+        }), switchMap(result => this._apiService.post(result.apiUrl, {
+            items: result.items,
+            affiliateKey,
+            paymentType
+        })), map(result => result.data));
+    }
+}
+SkCartService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCartService, deps: [{ token: SkAuthService }, { token: i1.SkApiService }, { token: SkCartApiService }, { token: SkCartLocalService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkCartService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCartService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCartService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: SkAuthService }, { type: i1.SkApiService }, { type: SkCartApiService }, { type: SkCartLocalService }]; } });
+
+class SkOrderService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    getAdminOrders(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/orders`, params.buildHttpParams())
+            .pipe(map(result => result.data));
+    }
+    getAdminOrdersCount() {
+        return this._apiService.get(`/api/admin/orders/count`)
+            .pipe(map(result => result.data));
+    }
+    getAdminOrder(id) {
+        return this._apiService.get(`/api/admin/orders/${id}`)
+            .pipe(map(result => new SkOrderDetail(result.data)));
+    }
+    getMyOrders() {
+        return this._apiService.get(`/api/public/orders/me`)
+            .pipe(map(result => result.data));
+    }
+    getMyLatestOrders() {
+        return this._apiService.get(`/api/public/orders/me/latest`)
+            .pipe(map(result => result.data));
+    }
+    getOrderDetail(id) {
+        return this._apiService.get(`/api/public/orders/${id}`)
+            .pipe(map(result => new SkOrderDetail(result.data)));
+    }
+    getOrderStatus(id) {
+        return this._apiService.get(`/api/public/orders/${id}/status`)
+            .pipe(map(result => result.data));
+    }
+    getOrderLogs(id) {
+        return this._apiService.get(`/api/admin/orders/${id}/logs`)
+            .pipe(map(result => result.data || []));
+    }
+    createAdminOrder(data) {
+        return this._apiService.post(`/api/admin/orders`, data)
+            .pipe(map(result => new SkOrderDetail(result.data)));
+    }
+    addOrderLog(id, message) {
+        return this._apiService.post(`/api/admin/orders/${id}/logs`, { message })
+            .pipe(map(result => result.data || []));
+    }
+    updateAdminOrderBaseInfo(id, data) {
+        return this._apiService.put(`/api/admin/orders/${id}/info`, data)
+            .pipe(map(result => result.data));
+    }
+    updateAdminConfirmTransferPayment(id) {
+        return this._apiService.put(`/api/admin/orders/${id}/confirm-payment/transfer`, null)
+            .pipe(map(result => result.data));
+    }
+    updateAdminCancel(id) {
+        return this._apiService.put(`/api/admin/orders/${id}/cancel`, {})
+            .pipe(map(result => result.data));
+    }
+    updateAdminCancelForce(id) {
+        return this._apiService.put(`/api/admin/orders/${id}/cancel/force`, {})
+            .pipe(map(result => result.data));
+    }
+    updateAdminProcessStart(id) {
+        return this._apiService.put(`/api/admin/orders/${id}/process-start`, {})
+            .pipe(map(result => result.data));
+    }
+    updateAdminComplete(id) {
+        return this._apiService.put(`/api/admin/orders/${id}/complete`, {})
+            .pipe(map(result => result.data));
+    }
+    updateAdminPayment(id, data) {
+        return this._apiService.put(`/api/admin/orders/${id}/update-payment`, data)
+            .pipe(map(result => result.data));
+    }
+    updateAdminShippingStatus(id, data) {
+        return this._apiService.put(`/api/admin/orders/${id}/update-shipping-status`, data)
+            .pipe(map(result => result.data));
+    }
+    deleteAdminOrders(orders) {
+        return this._apiService.delete(`/api/admin/orders/${orders.map(order => order.id).join(',')}`);
+    }
+    cancelOrder(id, data) {
+        return this._apiService.put(`/api/public/orders/${id}/cancel`, data)
+            .pipe(map(result => result.data));
+    }
+    startProgress(id, data) {
+        return this._apiService.put(`/api/public/orders/${id}/progress`, data)
+            .pipe(map(result => result.data));
+    }
+    moveToMyOrder(id) {
+        return this._apiService.put(`/api/public/orders/${id}/move`, {})
+            .pipe(map(result => result.data));
+    }
+    getAdminShippingFeeList() {
+        return this._apiService.get(`/api/admin/orders/shipping-fees`)
+            .pipe(map(result => result.data));
+    }
+    createAdminShippingFee(data) {
+        return this._apiService.post(`/api/admin/orders/shipping-fees`, data)
+            .pipe(map(result => result.data));
+    }
+    updateAdminShippingFee(id, data) {
+        return this._apiService.put(`/api/admin/orders/shipping-fees/${id}`, data)
+            .pipe(map(result => result.data));
+    }
+    deleteAdminShippingFee(id) {
+        return this._apiService.delete(`/api/admin/orders/shipping-fees/${id}`)
+            .pipe(map(result => result.data));
+    }
+    calculateShippingFee(id, method, zipCode, serials = []) {
+        return this._apiService.get(`/api/public/orders/${id}/calculate-shipping-fee`, new HttpParams().append('method', method).append('zipCode', zipCode).append('serials', serials.join(',')))
+            .pipe(map(result => result.data || 0));
+    }
+    validateCoupon(id, serials) {
+        return this._apiService.post(`/api/public/orders/${id}/check-coupon`, {
+            couponSerials: serials
+        }).pipe(map(result => result.data || { discountAmount: 0, couponData: [] }));
+    }
+}
+SkOrderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkOrderService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkOrderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkOrderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkOrderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkAccountService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    getDefaultAddress() {
+        return this._apiService.get(`/api/public/users/me/address/default`).pipe(map(response => response.data));
+    }
+    getAddressList() {
+        return this._apiService.get(`/api/public/users/me/address`).pipe(map(response => response.data || []));
+    }
+    updateAddress(id, data) {
+        return this._apiService.put(`/api/public/users/me/address/${id}`, data).pipe(map(response => response.data));
+    }
+    deleteAddress(id) {
+        return this._apiService.delete(`/api/public/users/me/address/${id}`);
+    }
+    getWishList() {
+        return this._apiService.get(`/api/public/users/me/wishlist`).pipe(map(response => response.data || []));
+    }
+    getWishListShowBadge() {
+        return this._apiService.get(`/api/public/users/me/wishlist/badge`).pipe(map(response => response.data || false));
+    }
+}
+SkAccountService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkAccountService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkAccountService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkAccountService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkAccountService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkSearchService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    getSearchResults(params = new ApiPageableParam()) {
+        return this._apiService.get(`/api/public/search`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getSearchKeywords() {
+        return this._apiService.get(`/api/public/search/keywords`).pipe(map(response => response.data));
+    }
+}
+SkSearchService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkSearchService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkSearchService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkSearchService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkSearchService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkPointService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+        this.apiServer = _apiService.apiServer;
+    }
+    getMyCurrentPoint() {
+        return this._apiService.get(`/api/public/points/me`).pipe(map(response => Number(response.data || 0)));
+    }
+    getMyPointHistory(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/public/points/me/history`, params.buildHttpParams()).pipe(map(response => response.data), map(value => {
+            value.content = (value.content || []).map(item => new SkPoint(item));
+            return value;
+        }));
+    }
+    getUserCurrentPoint(userId) {
+        return this._apiService.get(`/api/admin/points/${userId}`).pipe(map(response => Number(response.data || 0)));
+    }
+    getUserPointHistory(userId, params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/points/${userId}/history`, params.buildHttpParams()).pipe(map(response => response.data), map(value => {
+            value.content = (value.content || []).map(item => new SkPoint(item));
+            return value;
+        }));
+    }
+    addPointToUser(data) {
+        return this._apiService.put(`/api/admin/points/add`, data).pipe(map(response => Number(response.data || 0)));
+    }
+    usePointToUser(data) {
+        return this._apiService.put(`/api/admin/points/use`, data).pipe(map(response => Number(response.data || 0)));
+    }
+}
+SkPointService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkPointService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkPointService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkPointService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkPointService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkCouponService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    getCoupon(code) {
+        return this._apiService.get(`/api/public/coupons/${code}`).pipe(map(response => response.data));
+    }
+    getAdminCoupon(id) {
+        return this._apiService.get(`/api/admin/coupons/${id}`).pipe(map(response => response.data));
+    }
+    getCoupons(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/public/coupons`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getCouponTickets(id) {
+        return this._apiService.get(`/api/admin/coupons/${id}/list`).pipe(map(response => response.data || []));
+    }
+    getAdminCoupons(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/coupons`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getCouponsArray(ids) {
+        return this._apiService.get(`/api/public/coupons/array/${ids.join(',')}`).pipe(map(response => response.data));
+    }
+    getAdminCouponsArray(ids) {
+        return this._apiService.get(`/api/admin/coupons/array/${ids.join(',')}`).pipe(map(response => response.data));
+    }
+    createAdminCoupon(data) {
+        return this._apiService.post(`/api/admin/coupons`, data).pipe(map(response => response.data));
+    }
+    updateAdminCoupon(id, data) {
+        return this._apiService.put(`/api/admin/coupons/${id}`, data).pipe(map(response => response.data));
+    }
+    updateAdminCouponTrigger(id, data) {
+        return this._apiService.put(`/api/admin/coupons/${id}/trigger`, data).pipe(map(response => response.data));
+    }
+    activateAdminCoupons(coupons) {
+        return this._apiService.put(`/api/admin/coupons/activate/${coupons.map(coupon => coupon.id).join(',')}`, null);
+    }
+    deactivateAdminCoupons(coupons) {
+        return this._apiService.put(`/api/admin/coupons/deactivate/${coupons.map(coupon => coupon.id).join(',')}`, null);
+    }
+    deleteAdminCoupons(coupons) {
+        return this._apiService.delete(`/api/admin/coupons/delete/${coupons.map(coupon => coupon.id).join(',')}`);
+    }
+    getAdminCouponsCount() {
+        return this._apiService.get('/api/admin/coupons/count')
+            .pipe(map(response => response.data));
+    }
+}
+SkCouponService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCouponService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkCouponService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCouponService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCouponService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkCommentService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    getDocumentComments(param = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/public/document-comments`, param.buildHttpParams())
+            .pipe(map(response => {
+            response.data.content = response.data.content.map(item => new SkDocumentCommentParent(item));
+            return response.data;
+        }));
+    }
+    getDocumentComment(id) {
+        return this._apiService.get(`/api/public/document-comments/${id}`)
+            .pipe(map(response => new SkDocumentCommentParent(response.data)));
+    }
+    writeDocumentComment(data) {
+        return this._apiService.post(`/api/public/document-comments`, data)
+            .pipe(map(response => response.data));
+    }
+    updateDocumentComment(id, data) {
+        return this._apiService.put(`/api/public/document-comments/${id}`, data)
+            .pipe(map(response => response.data));
+    }
+    deleteDocumentComment(id) {
+        return this._apiService.delete(`/api/public/document-comments/${id}`)
+            .pipe(map(response => response.data));
+    }
+}
+SkCommentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCommentService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkCommentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCommentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkCommentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkContactService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    writeContact(data) {
+        return this._apiService.post(`/api/public/contacts`, data)
+            .pipe(map(response => response.data));
+    }
+    getContacts(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/contacts`, params.buildHttpParams())
+            .pipe(map(response => response.data));
+    }
+    getContact(id) {
+        return this._apiService.get(`/api/admin/contacts/${id}`)
+            .pipe(map(response => response.data));
+    }
+    writeAnswerAdmin(id, data) {
+        return this._apiService.post(`/api/admin/contacts/${id}/answer`, data)
+            .pipe(map(response => response.data));
+    }
+    closeContact(id) {
+        return this._apiService.put(`/api/admin/contacts/${id}/close`, null)
+            .pipe(map(response => response.data));
+    }
+}
+SkContactService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkContactService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkContactService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkContactService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkContactService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkEtcService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    sendTestEmail(key, params) {
+        return this._apiService.get(`/api/admin/notifications/email/${key}`, params).pipe(map(response => response.data));
+    }
+    sendTestSms(key, to) {
+        return this._apiService.get(`/api/admin/notifications/sms/${key}`, new HttpParams().append('to', to)).pipe(map(response => response.data));
+    }
+}
+SkEtcService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkEtcService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkEtcService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkEtcService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkEtcService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkStoreService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    getStore(id) {
+        return this._apiService.get(`/api/public/stores/${id}`).pipe(map(response => new SkStore(response.data)));
+    }
+    getAdminStore(id) {
+        return this._apiService.get(`/api/admin/stores/${id}`).pipe(map(response => new SkStore(response.data)));
+    }
+    getStores(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/public/stores`, params.buildHttpParams()).pipe(map(response => {
+            response.data.content = (response.data.content || []).map(item => new SkStore(item));
+            return response.data;
+        }));
+    }
+    getAdminStores(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/stores`, params.buildHttpParams()).pipe(map(response => {
+            response.data.content = (response.data.content || []).map(item => new SkStore(item));
+            return response.data;
+        }));
+    }
+    createAdminStore(data) {
+        return this._apiService.post(`/api/admin/stores`, data).pipe(map(response => response.data));
+    }
+    updateAdminStore(id, data) {
+        return this._apiService.put(`/api/admin/stores/${id}`, data).pipe(map(response => response.data));
+    }
+    deleteAdminStores(stores) {
+        return this._apiService.delete(`/api/admin/stores/delete/${stores.map(store => store.id).join(',')}`);
+    }
+}
+SkStoreService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkStoreService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkStoreService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkStoreService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkStoreService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+class SkKeywordService {
+    constructor(_apiService) {
+        this._apiService = _apiService;
+    }
+    getKeyword(id) {
+        return this._apiService.get(`/api/public/keywords/${id}`).pipe(map(response => response.data));
+    }
+    getAdminKeyword(id) {
+        return this._apiService.get(`/api/admin/keywords/${id}`).pipe(map(response => response.data));
+    }
+    getKeywords(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/public/keywords`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getAllKeywords(params = new ApiPageableParam()) {
+        return this._apiService.get(`/api/public/keywords/all`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getAdminKeywords(params = new ApiPageableParam()) {
+        return this._apiService.getPageable(`/api/admin/keywords`, params.buildHttpParams()).pipe(map(response => response.data));
+    }
+    getAdminAllKeywords() {
+        return this._apiService.get(`/api/admin/keywords/all`).pipe(map(response => response.data));
+    }
+    createAdminKeyword(data) {
+        return this._apiService.post(`/api/admin/keywords`, data).pipe(map(response => response.data));
+    }
+    updateAdminKeyword(id, data) {
+        return this._apiService.put(`/api/admin/keywords/${id}`, data).pipe(map(response => response.data));
+    }
+    deleteAdminKeywords(keywords) {
+        return this._apiService.delete(`/api/admin/keywords/delete/${keywords.map(keyword => keyword.id).join(',')}`);
+    }
+}
+SkKeywordService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkKeywordService, deps: [{ token: i1.SkApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkKeywordService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkKeywordService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: SkKeywordService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { SkAccountService, SkAffiliateService, SkAuthAdminGuard, SkAuthGuard, SkAuthService, SkBoardService, SkBrandService, SkCartService, SkCategoryService, SkCommentService, SkConfigService, SkContactService, SkCouponService, SkDocumentService, SkEtcService, SkFileService, SkKeywordService, SkOrderService, SkPointService, SkProductService, SkPromotionService, SkSearchService, SkStoreService, SkUserService };
+//# sourceMappingURL=sk-front-lib-crud.mjs.map