@tuki-io/tuki-widgets 0.0.219-dev.38 → 0.0.219-dev.39

package/esm2020/workspaces/src/services/api.service.mjs

@@ -0,0 +1,67 @@
+import { Injectable } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class APIService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    fetch(url, params, cache) {
+        const headers = this.getHeaders(cache);
+        params = params || {};
+        return this.httpClient.get(this.apiUrl + url, { params: this.prepareEncodedParams(params), headers });
+    }
+    post(url, body, params = {}) {
+        body = body || null;
+        const headers = this.getHeaders();
+        return this.httpClient.post(this.apiUrl + url, body, { params: this.prepareEncodedParams(params), headers });
+    }
+    put(url, body = null, params = {}) {
+        const headers = this.getHeaders();
+        return this.httpClient.put(this.apiUrl + url, body, { headers, params: this.prepareEncodedParams(params) });
+    }
+    delete(url, params = {}) {
+        const headers = this.getHeaders();
+        return this.httpClient.delete(this.apiUrl + url, { headers, params: this.prepareEncodedParams(params) });
+    }
+    prepareEncodedParams(params) {
+        const result = {};
+        if (!params) {
+            return {};
+        }
+        for (const key of Object.keys(params)) {
+            if (params[key] !== undefined && params[key] !== null && params[key] !== '') {
+                const stringParam = params[key].toString();
+                result[key] = stringParam.includes('+') ? encodeURIComponent(stringParam) : stringParam;
+            }
+        }
+        return result;
+    }
+    getHeaders(cache) {
+        let headers = new HttpHeaders();
+        if (cache) {
+            headers = headers.append('_Cache', 'true ');
+        }
+        const token = this.token || this.getParameterByName('token');
+        headers = headers.append('Authorization', 'Bearer ' + token);
+        return headers;
+    }
+    getParameterByName(name, url = window.location.href) {
+        name = name.replace(/[\[\]]/g, '\\$&');
+        var regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)'), results = regex.exec(url);
+        if (!results)
+            return null;
+        if (!results[2])
+            return '';
+        return decodeURIComponent(results[2].replace(/\+/g, ' '));
+    }
+}
+APIService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: APIService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+APIService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: APIService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: APIService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/workspaces/src/services/workspace-detail.service.mjs

@@ -0,0 +1,54 @@
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import * as i0 from "@angular/core";
+// No dedicated detail API exists yet, so the Overview/Calling tabs are
+// populated with mock data derived from the already-loaded workspace record.
+export class WorkspaceDetailService {
+    getByWorkspace(workspace) {
+        const device = workspace.device;
+        const directoryNumber = device.associatedDNs?.[0]?.directoryNumber ?? '';
+        const sipAddress = `${(device.name || workspace.displayName || 'workspace').toLowerCase()}@tukidev.rooms.webex.com`;
+        const issues = [
+            !workspace.typeLabel || workspace.typeLabel === 'No type' ? {
+                id: 'type',
+                message: 'Workspace type not set',
+                timestamp: 'Just now',
+                actionLabel: 'Assign type',
+            } : null,
+            workspace.capacity == null ? {
+                id: 'capacity',
+                message: 'Workspace capacity not set',
+                timestamp: 'Just now',
+                actionLabel: 'Set capacity',
+            } : null,
+        ].filter((issue) => issue !== null);
+        const details = {
+            issues,
+            location: {
+                country: workspace.location || 'Not set',
+                address: device.location || 'Address not available',
+            },
+            calling: {
+                license: workspace.callingLicense || 'Cisco Webex Calling Professional Workspace',
+                sipAddress,
+                directoryNumber: directoryNumber || 'Not assigned',
+                routePartition: device.associatedDNs?.[0]?.routePartitionName || 'Not set',
+                callingSearchSpace: device.callingSearchSpaceName || 'Not set',
+                securityProfile: device.securityProfile || 'Not set',
+            },
+            schedulingConfigured: false,
+            plannedMaintenanceEnabled: false,
+            notes: null,
+        };
+        return of(details);
+    }
+}
+WorkspaceDetailService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspaceDetailService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+WorkspaceDetailService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspaceDetailService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspaceDetailService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/workspaces/src/services/workspaces.service.mjs

@@ -0,0 +1,90 @@
+import { Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { API } from '../app.constants';
+import * as i0 from "@angular/core";
+import * as i1 from "./api.service";
+function parseResponse(response) {
+    return typeof response === 'string' ? JSON.parse(response) : response;
+}
+function toStatus(provisioningStatus) {
+    if (!provisioningStatus) {
+        return 'unavailable';
+    }
+    return provisioningStatus.toLowerCase() === 'active' ? 'active' : 'inactive';
+}
+function toWorkspace(item, index) {
+    const device = item.device;
+    const firstDirectoryNumber = device.associatedDNs?.[0]?.directoryNumber ?? '';
+    return {
+        id: device.pkid || item.workspaceDevices?.[0]?.deviceId || device.name || `workspace-${index}`,
+        displayName: device.newName || device.name || 'Unnamed device',
+        typeLabel: device.userDeviceType || 'No type',
+        capacity: null,
+        location: item.site?.name || device.siteName || device.location || '',
+        devices: (item.workspaceDevices || []).map(workspaceDevice => ({
+            id: workspaceDevice.deviceId,
+            kind: 'device',
+            label: workspaceDevice.model || workspaceDevice.mac,
+            model: workspaceDevice.model,
+        })),
+        scheduling: 'Not set',
+        callingLicense: firstDirectoryNumber,
+        provisioningType: 'On-premises',
+        status: toStatus(device.provisioningStatus),
+        statusLabel: device.provisioningStatus || 'Status unavailable',
+        device,
+        isHybrid: false,
+    };
+}
+function mergeDevices(a, b) {
+    return {
+        ...a,
+        ...b,
+        cucmId: b.cucmId ?? a.cucmId,
+        webexUUID: b.webexUUID ?? a.webexUUID,
+    };
+}
+function mergeWorkspacesByDeviceName(workspaces) {
+    const merged = new Map();
+    for (const workspace of workspaces) {
+        const key = workspace.device.name;
+        const existing = merged.get(key);
+        merged.set(key, existing ? {
+            ...existing,
+            ...workspace,
+            device: mergeDevices(existing.device, workspace.device),
+            isHybrid: true,
+        } : workspace);
+    }
+    return Array.from(merged.values());
+}
+export class WorkspacesService {
+    constructor(apiService) {
+        this.apiService = apiService;
+    }
+    fetchWorkspaces(customerId, size = 10, page = 0) {
+        const queryParams = {
+            type: 'ORPHAN_DEVICE',
+            'device-name': 'SEP',
+            customerid: customerId.toString(),
+            size: size.toString(),
+            page: page.toString(),
+        };
+        return this.apiService.fetch(API.WORKSPACES.GET_ALL, queryParams).pipe(map((response) => {
+            const parsed = parseResponse(response);
+            return {
+                workspaces: mergeWorkspacesByDeviceName((parsed?.pageData || []).map(toWorkspace)),
+                total: parsed?.total ?? 0,
+            };
+        }));
+    }
+}
+WorkspacesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspacesService, deps: [{ token: i1.APIService }], target: i0.ɵɵFactoryTarget.Injectable });
+WorkspacesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspacesService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspacesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.APIService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspaces.service.js","sourceRoot":"","sources":["../../../../../../../projects/tuki/widgets/workspaces/src/services/workspaces.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { Observable } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\nimport { API } from '../app.constants';\r\nimport { APIService } from './api.service';\r\nimport { Workspace, WorkspaceListItem, WorkspacesPage, WorkspacesResponse, WorkspaceStatus } from '../types/workspace';\r\n\r\nfunction parseResponse(response: any): any {\r\n  return typeof response === 'string' ? JSON.parse(response) : response;\r\n}\r\n\r\nfunction toStatus(provisioningStatus: string | null): WorkspaceStatus {\r\n  if (!provisioningStatus) {\r\n    return 'unavailable';\r\n  }\r\n  return provisioningStatus.toLowerCase() === 'active' ? 'active' : 'inactive';\r\n}\r\n\r\nfunction toWorkspace(item: WorkspaceListItem, index: number): Workspace {\r\n  const device = item.device;\r\n  const firstDirectoryNumber = device.associatedDNs?.[0]?.directoryNumber ?? '';\r\n\r\n  return {\r\n    id: device.pkid || item.workspaceDevices?.[0]?.deviceId || device.name || `workspace-${index}`,\r\n    displayName: device.newName || device.name || 'Unnamed device',\r\n    typeLabel: device.userDeviceType || 'No type',\r\n    capacity: null,\r\n    location: item.site?.name || device.siteName || device.location || '',\r\n    devices: (item.workspaceDevices || []).map(workspaceDevice => ({\r\n      id: workspaceDevice.deviceId,\r\n      kind: 'device' as const,\r\n      label: workspaceDevice.model || workspaceDevice.mac,\r\n      model: workspaceDevice.model,\r\n    })),\r\n    scheduling: 'Not set',\r\n    callingLicense: firstDirectoryNumber,\r\n    provisioningType: 'On-premises',\r\n    status: toStatus(device.provisioningStatus),\r\n    statusLabel: device.provisioningStatus || 'Status unavailable',\r\n    device,\r\n    isHybrid: false,\r\n  };\r\n}\r\n\r\nfunction mergeDevices(a: Workspace['device'], b: Workspace['device']): Workspace['device'] {\r\n  return {\r\n    ...a,\r\n    ...b,\r\n    cucmId: b.cucmId ?? a.cucmId,\r\n    webexUUID: b.webexUUID ?? a.webexUUID,\r\n  };\r\n}\r\n\r\nfunction mergeWorkspacesByDeviceName(workspaces: Workspace[]): Workspace[] {\r\n  const merged = new Map<string, Workspace>();\r\n\r\n  for (const workspace of workspaces) {\r\n    const key = workspace.device.name;\r\n    const existing = merged.get(key);\r\n    merged.set(key, existing ? {\r\n      ...existing,\r\n      ...workspace,\r\n      device: mergeDevices(existing.device, workspace.device),\r\n      isHybrid: true,\r\n    } : workspace);\r\n  }\r\n\r\n  return Array.from(merged.values());\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class WorkspacesService {\r\n  constructor(private apiService: APIService) { }\r\n\r\n  fetchWorkspaces(\r\n    customerId: string | number,\r\n    size = 10,\r\n    page = 0,\r\n  ): Observable<WorkspacesPage> {\r\n    const queryParams: Record<string, string> = {\r\n      type: 'ORPHAN_DEVICE',\r\n      'device-name': 'SEP',\r\n      customerid: customerId.toString(),\r\n      size: size.toString(),\r\n      page: page.toString(),\r\n    };\r\n    return this.apiService.fetch(API.WORKSPACES.GET_ALL, queryParams).pipe(\r\n      map((response: any) => {\r\n        const parsed = parseResponse(response) as WorkspacesResponse;\r\n        return {\r\n          workspaces: mergeWorkspacesByDeviceName((parsed?.pageData || []).map(toWorkspace)),\r\n          total: parsed?.total ?? 0,\r\n        };\r\n      }),\r\n    );\r\n  }\r\n}\r\n"]}

package/esm2020/workspaces/src/types/workspace.mjs

@@ -0,0 +1,4 @@
+// Raw shapes returned by /api/search/quicknonuserdevices (a paginated CUCM
+// non-user/shared device search, reused here as the "Workspaces" list).
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/workspaces/src/utils/app-loader/app-loader.mjs

@@ -0,0 +1,14 @@
+import { Component, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/progress-spinner";
+export class AppLoaderComponent {
+    constructor() {
+    }
+}
+AppLoaderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AppLoaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+AppLoaderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: AppLoaderComponent, selector: "app-loader", ngImport: i0, template: "<div class=\"overlay\">\r\n  <mat-progress-spinner\r\n    class=\"page-spinner\"\r\n    mode=\"indeterminate\"\r\n    [diameter]=\"70\"\r\n    strokeWidth=\"3\"></mat-progress-spinner>\r\n</div>\r\n", styles: [".overlay{position:fixed;width:100%;height:100%;inset:0;background-color:#fff3;z-index:200}.mat-progress-spinner circle,.mat-spinner circle{stroke:#000!important}\n"], dependencies: [{ kind: "component", type: i1.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "diameter", "strokeWidth", "mode", "value"], exportAs: ["matProgressSpinner"] }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AppLoaderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-loader', encapsulation: ViewEncapsulation.None, template: "<div class=\"overlay\">\r\n  <mat-progress-spinner\r\n    class=\"page-spinner\"\r\n    mode=\"indeterminate\"\r\n    [diameter]=\"70\"\r\n    strokeWidth=\"3\"></mat-progress-spinner>\r\n</div>\r\n", styles: [".overlay{position:fixed;width:100%;height:100%;inset:0;background-color:#fff3;z-index:200}.mat-progress-spinner circle,.mat-spinner circle{stroke:#000!important}\n"] }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLWxvYWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R1a2kvd2lkZ2V0cy93b3Jrc3BhY2VzL3NyYy91dGlscy9hcHAtbG9hZGVyL2FwcC1sb2FkZXIudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dWtpL3dpZGdldHMvd29ya3NwYWNlcy9zcmMvdXRpbHMvYXBwLWxvYWRlci9hcHAtbG9hZGVyLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxlQUFlLENBQUM7OztBQVE3RCxNQUFNLE9BQU8sa0JBQWtCO0lBQzdCO0lBQ0EsQ0FBQzs7Z0hBRlUsa0JBQWtCO29HQUFsQixrQkFBa0Isa0RDUi9CLHdNQU9BOzRGRENhLGtCQUFrQjtrQkFOOUIsU0FBUzsrQkFDRSxZQUFZLGlCQUdQLGlCQUFpQixDQUFDLElBQUkiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQsIFZpZXdFbmNhcHN1bGF0aW9uIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5AQ29tcG9uZW50KHtcclxuICBzZWxlY3RvcjogJ2FwcC1sb2FkZXInLFxyXG4gIHRlbXBsYXRlVXJsOiAnLi9hcHAtbG9hZGVyLmNvbXBvbmVudC5odG1sJyxcclxuICBzdHlsZVVybHM6IFsnLi9hcHAtbG9hZGVyLmNvbXBvbmVudC5zY3NzJ10sXHJcbiAgZW5jYXBzdWxhdGlvbjogVmlld0VuY2Fwc3VsYXRpb24uTm9uZSxcclxufSlcclxuZXhwb3J0IGNsYXNzIEFwcExvYWRlckNvbXBvbmVudCB7XHJcbiAgY29uc3RydWN0b3IoKSB7XHJcbiAgfVxyXG5cclxufVxyXG4iLCI8ZGl2IGNsYXNzPVwib3ZlcmxheVwiPlxyXG4gIDxtYXQtcHJvZ3Jlc3Mtc3Bpbm5lclxyXG4gICAgY2xhc3M9XCJwYWdlLXNwaW5uZXJcIlxyXG4gICAgbW9kZT1cImluZGV0ZXJtaW5hdGVcIlxyXG4gICAgW2RpYW1ldGVyXT1cIjcwXCJcclxuICAgIHN0cm9rZVdpZHRoPVwiM1wiPjwvbWF0LXByb2dyZXNzLXNwaW5uZXI+XHJcbjwvZGl2PlxyXG4iXX0=

package/esm2020/workspaces/src/utils/device-icon.mjs

@@ -0,0 +1,13 @@
+const DEFAULT_DEVICE_ICON = 'assets/icons/cisco_8851.png';
+const DEVICE_MODEL_ICONS = {
+    'cisco 8851': 'assets/icons/cisco_8851.png',
+    'cisco 8845': 'assets/icons/cisco_8845.png',
+    'cisco 9841': 'assets/icons/cisco_9841.png',
+};
+export function getDeviceIcon(model) {
+    if (!model) {
+        return DEFAULT_DEVICE_ICON;
+    }
+    return DEVICE_MODEL_ICONS[model.trim().toLowerCase()] ?? DEFAULT_DEVICE_ICON;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGV2aWNlLWljb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dWtpL3dpZGdldHMvd29ya3NwYWNlcy9zcmMvdXRpbHMvZGV2aWNlLWljb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxtQkFBbUIsR0FBRyw2QkFBNkIsQ0FBQztBQUUxRCxNQUFNLGtCQUFrQixHQUEyQjtJQUNqRCxZQUFZLEVBQUUsNkJBQTZCO0lBQzNDLFlBQVksRUFBRSw2QkFBNkI7SUFDM0MsWUFBWSxFQUFFLDZCQUE2QjtDQUM1QyxDQUFDO0FBRUYsTUFBTSxVQUFVLGFBQWEsQ0FBQyxLQUFjO0lBQzFDLElBQUksQ0FBQyxLQUFLLEVBQUU7UUFDVixPQUFPLG1CQUFtQixDQUFDO0tBQzVCO0lBQ0QsT0FBTyxrQkFBa0IsQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUMsV0FBVyxFQUFFLENBQUMsSUFBSSxtQkFBbUIsQ0FBQztBQUMvRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiY29uc3QgREVGQVVMVF9ERVZJQ0VfSUNPTiA9ICdhc3NldHMvaWNvbnMvY2lzY29fODg1MS5wbmcnO1xyXG5cclxuY29uc3QgREVWSUNFX01PREVMX0lDT05TOiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmc+ID0ge1xyXG4gICdjaXNjbyA4ODUxJzogJ2Fzc2V0cy9pY29ucy9jaXNjb184ODUxLnBuZycsXHJcbiAgJ2Npc2NvIDg4NDUnOiAnYXNzZXRzL2ljb25zL2Npc2NvXzg4NDUucG5nJyxcclxuICAnY2lzY28gOTg0MSc6ICdhc3NldHMvaWNvbnMvY2lzY29fOTg0MS5wbmcnLFxyXG59O1xyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIGdldERldmljZUljb24obW9kZWw/OiBzdHJpbmcpOiBzdHJpbmcge1xyXG4gIGlmICghbW9kZWwpIHtcclxuICAgIHJldHVybiBERUZBVUxUX0RFVklDRV9JQ09OO1xyXG4gIH1cclxuICByZXR1cm4gREVWSUNFX01PREVMX0lDT05TW21vZGVsLnRyaW0oKS50b0xvd2VyQ2FzZSgpXSA/PyBERUZBVUxUX0RFVklDRV9JQ09OO1xyXG59XHJcbiJdfQ==

package/esm2020/workspaces/src/workspaces.component.mjs

@@ -0,0 +1,124 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./services/api.service";
+import * as i2 from "./services/workspaces.service";
+import * as i3 from "@angular/common";
+import * as i4 from "./components/workspaces-filters/workspaces-filters.component";
+import * as i5 from "./components/workspaces-table/workspaces-table.component";
+import * as i6 from "./components/workspace-detail/workspace-detail.component";
+import * as i7 from "./utils/app-loader/app-loader";
+export class WorkspacesComponent {
+    constructor(apiService, workspacesService, location) {
+        this.apiService = apiService;
+        this.workspacesService = workspacesService;
+        this.location = location;
+        this.addWorkspace = new EventEmitter();
+        this.openWorkspace = new EventEmitter();
+        this.editWorkspace = new EventEmitter();
+        this.deleteWorkspace = new EventEmitter();
+        this.addDevice = new EventEmitter();
+        this.tabs = [
+            { id: 'workspaces', label: 'Workspaces', icon: 'assets/icons/device-in-room-regular.svg' },
+            { id: 'insights', label: 'Insights', icon: 'assets/icons/analysis-regular.svg' },
+            { id: 'integrations', label: 'Integrations', icon: 'assets/icons/integrations-regular.svg' },
+            { id: 'settings', label: 'Settings', icon: 'assets/icons/tools-regular.svg' },
+        ];
+        this.activeTab = 'workspaces';
+        this.view = 'list';
+        this.selectedWorkspace = null;
+        this.workspaces = [];
+        this.isLoading = false;
+        this.pageIndex = 0;
+        this.pageSize = 10;
+        this.total = 0;
+        this.searchTerm = '';
+        this.typeFilter = '';
+        this.locationFilter = '';
+    }
+    ngOnInit() {
+        this.apiService.token = this.token;
+        this.apiService.apiUrl = this.host + '/dcp';
+        this.fetchWorkspaces();
+    }
+    get typeOptions() {
+        return [...new Set(this.workspaces.map(workspace => workspace.typeLabel).filter(Boolean))];
+    }
+    get locationOptions() {
+        return [...new Set(this.workspaces.map(workspace => workspace.location).filter(Boolean))];
+    }
+    get filteredWorkspaces() {
+        const term = this.searchTerm.trim().toLowerCase();
+        return this.workspaces.filter(workspace => (!term || workspace.displayName.toLowerCase().includes(term) || workspace.location.toLowerCase().includes(term)) &&
+            (!this.typeFilter || workspace.typeLabel === this.typeFilter) &&
+            (!this.locationFilter || workspace.location === this.locationFilter));
+    }
+    selectTab(tab) {
+        this.activeTab = tab;
+    }
+    onOpenWorkspace(id) {
+        const workspace = this.workspaces.find(item => item.id === id) ?? null;
+        this.openWorkspace.emit(id);
+        if (!workspace) {
+            return;
+        }
+        this.selectedWorkspace = workspace;
+        this.view = 'detail';
+    }
+    onBackToList() {
+        this.view = 'list';
+        this.selectedWorkspace = null;
+        this.location.replaceState('/workspaces');
+    }
+    onSearchChange(term) {
+        this.searchTerm = term;
+    }
+    onTypeFilterChange(type) {
+        this.typeFilter = type;
+    }
+    onLocationFilterChange(location) {
+        this.locationFilter = location;
+    }
+    onPageChange({ pageIndex, pageSize }) {
+        this.pageIndex = pageIndex;
+        this.pageSize = pageSize;
+        this.fetchWorkspaces();
+    }
+    fetchWorkspaces() {
+        this.isLoading = true;
+        this.workspacesService.fetchWorkspaces(this.customerId, this.pageSize, this.pageIndex).subscribe({
+            next: ({ workspaces, total }) => {
+                this.workspaces = workspaces;
+                this.total = total;
+                this.isLoading = false;
+            },
+            error: () => {
+                this.workspaces = [];
+                this.total = 0;
+                this.isLoading = false;
+            },
+        });
+    }
+}
+WorkspacesComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspacesComponent, deps: [{ token: i1.APIService }, { token: i2.WorkspacesService }, { token: i3.Location }], target: i0.ɵɵFactoryTarget.Component });
+WorkspacesComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: WorkspacesComponent, selector: "tk-workspaces", inputs: { host: "host", token: "token", customerId: "customerId" }, outputs: { addWorkspace: "addWorkspace", openWorkspace: "openWorkspace", editWorkspace: "editWorkspace", deleteWorkspace: "deleteWorkspace", addDevice: "addDevice" }, ngImport: i0, template: "<div class=\"tk-workspaces\">\r\n  <ng-container *ngIf=\"view === 'list'; else detailView\">\r\n    <header class=\"tk-workspaces__header\">\r\n      <h1 class=\"tk-workspaces__title\">Workspaces</h1>\r\n    </header>\r\n\r\n    <nav class=\"tk-workspaces__tabs\">\r\n      <button\r\n        type=\"button\"\r\n        *ngFor=\"let tab of tabs\"\r\n        class=\"tk-workspaces__tab\"\r\n        [class.tk-workspaces__tab--active]=\"activeTab === tab.id\"\r\n        (click)=\"selectTab(tab.id)\">\r\n        <img class=\"tk-workspaces__tab-icon\" [src]=\"tab.icon\" alt=\"\" />\r\n        {{ tab.label }}\r\n      </button>\r\n    </nav>\r\n\r\n    <ng-container *ngIf=\"activeTab === 'workspaces'; else placeholder\">\r\n      <app-loader *ngIf=\"isLoading\"></app-loader>\r\n\r\n      <tk-workspaces-filters\r\n        [resultCount]=\"total\"\r\n        [typeOptions]=\"typeOptions\"\r\n        [locationOptions]=\"locationOptions\"\r\n        (searchChange)=\"onSearchChange($event)\"\r\n        (typeChange)=\"onTypeFilterChange($event)\"\r\n        (locationChange)=\"onLocationFilterChange($event)\"\r\n        (addWorkspace)=\"addWorkspace.emit()\">\r\n      </tk-workspaces-filters>\r\n\r\n      <tk-workspaces-table\r\n        [workspaces]=\"filteredWorkspaces\"\r\n        [total]=\"total\"\r\n        [pageIndex]=\"pageIndex\"\r\n        [pageSize]=\"pageSize\"\r\n        (openWorkspace)=\"onOpenWorkspace($event)\"\r\n        (editWorkspace)=\"editWorkspace.emit($event)\"\r\n        (deleteWorkspace)=\"deleteWorkspace.emit($event)\"\r\n        (addDevice)=\"addDevice.emit($event)\"\r\n        (pageChange)=\"onPageChange($event)\">\r\n      </tk-workspaces-table>\r\n    </ng-container>\r\n\r\n    <ng-template #placeholder>\r\n      <div class=\"tk-workspaces__placeholder\">This section isn't available in this widget yet.</div>\r\n    </ng-template>\r\n  </ng-container>\r\n\r\n  <ng-template #detailView>\r\n    <tk-workspace-detail\r\n      *ngIf=\"selectedWorkspace\"\r\n      [workspace]=\"selectedWorkspace\"\r\n      (back)=\"onBackToList()\">\r\n    </tk-workspace-detail>\r\n  </ng-template>\r\n</div>\r\n", styles: ["@import\"https://fonts.googleapis.com/css2?family=Inter:wght@300;400&display=swap\";.tk-workspaces{font-family:Inter,Helvetica Neue,Helvetica,Arial,sans-serif;color:#000000f2;padding:1.5rem}.tk-workspaces__header{display:flex;align-items:flex-start;justify-content:space-between;gap:1rem;padding-bottom:1rem}.tk-workspaces__title{margin:0;font-size:1.5rem;font-weight:600}.tk-workspaces__tabs{display:flex;align-items:center;gap:.25rem;margin-bottom:1rem}.tk-workspaces__tab{display:inline-flex;align-items:center;gap:.375rem;padding:.5rem .875rem;background:none;border:none;border-radius:6.25rem;font-family:inherit;font-size:1rem;font-weight:500;color:#000000b3;cursor:pointer}.tk-workspaces__tab:hover{background:rgba(0,0,0,.0705882353)}.tk-workspaces__tab--active{background:#C1C1C1;color:#000000f2}.tk-workspaces__tab--active:hover{background:rgba(0,0,0,.3019607843)}.tk-workspaces__tab-icon{height:1.125rem;width:1.125rem;opacity:.6}.tk-workspaces__tab--active .tk-workspaces__tab-icon{opacity:1}.tk-workspaces__placeholder{padding:3rem 1rem;text-align:center;color:#0009}::ng-deep input.blue-input{border:solid .0625rem rgba(0,0,0,.5019607843)!important}::ng-deep input.blue-input:focus{display:flex;align-items:center;color:#000000b3;background-color:#ededed;border:solid .0625rem rgba(0,0,0,.5019607843);font-weight:500;cursor:pointer;flex-wrap:wrap;gap:.5rem;box-shadow:0 0 0 .12rem #fff,0 0 0 .25rem #1170cf,0 0 0 .3rem #1170cf59;background-color:#fff!important}::ng-deep input.blue-input:focus:focus-visible{outline:none}::ng-deep input.blue-input:hover{background-color:#00000012!important}.data-loader{position:absolute;top:calc(50% - 25px);left:calc(50% - 25px)}\n"], dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.WorkspacesFiltersComponent, selector: "tk-workspaces-filters", inputs: ["resultCount", "typeOptions", "locationOptions"], outputs: ["searchChange", "typeChange", "locationChange", "addWorkspace"] }, { kind: "component", type: i5.WorkspacesTableComponent, selector: "tk-workspaces-table", inputs: ["workspaces", "total", "pageIndex", "pageSize", "pageSizeOptions"], outputs: ["openWorkspace", "editWorkspace", "deleteWorkspace", "addDevice", "pageChange"] }, { kind: "component", type: i6.WorkspaceDetailComponent, selector: "tk-workspace-detail", inputs: ["workspace"], outputs: ["back"] }, { kind: "component", type: i7.AppLoaderComponent, selector: "app-loader" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspacesComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tk-workspaces', template: "<div class=\"tk-workspaces\">\r\n  <ng-container *ngIf=\"view === 'list'; else detailView\">\r\n    <header class=\"tk-workspaces__header\">\r\n      <h1 class=\"tk-workspaces__title\">Workspaces</h1>\r\n    </header>\r\n\r\n    <nav class=\"tk-workspaces__tabs\">\r\n      <button\r\n        type=\"button\"\r\n        *ngFor=\"let tab of tabs\"\r\n        class=\"tk-workspaces__tab\"\r\n        [class.tk-workspaces__tab--active]=\"activeTab === tab.id\"\r\n        (click)=\"selectTab(tab.id)\">\r\n        <img class=\"tk-workspaces__tab-icon\" [src]=\"tab.icon\" alt=\"\" />\r\n        {{ tab.label }}\r\n      </button>\r\n    </nav>\r\n\r\n    <ng-container *ngIf=\"activeTab === 'workspaces'; else placeholder\">\r\n      <app-loader *ngIf=\"isLoading\"></app-loader>\r\n\r\n      <tk-workspaces-filters\r\n        [resultCount]=\"total\"\r\n        [typeOptions]=\"typeOptions\"\r\n        [locationOptions]=\"locationOptions\"\r\n        (searchChange)=\"onSearchChange($event)\"\r\n        (typeChange)=\"onTypeFilterChange($event)\"\r\n        (locationChange)=\"onLocationFilterChange($event)\"\r\n        (addWorkspace)=\"addWorkspace.emit()\">\r\n      </tk-workspaces-filters>\r\n\r\n      <tk-workspaces-table\r\n        [workspaces]=\"filteredWorkspaces\"\r\n        [total]=\"total\"\r\n        [pageIndex]=\"pageIndex\"\r\n        [pageSize]=\"pageSize\"\r\n        (openWorkspace)=\"onOpenWorkspace($event)\"\r\n        (editWorkspace)=\"editWorkspace.emit($event)\"\r\n        (deleteWorkspace)=\"deleteWorkspace.emit($event)\"\r\n        (addDevice)=\"addDevice.emit($event)\"\r\n        (pageChange)=\"onPageChange($event)\">\r\n      </tk-workspaces-table>\r\n    </ng-container>\r\n\r\n    <ng-template #placeholder>\r\n      <div class=\"tk-workspaces__placeholder\">This section isn't available in this widget yet.</div>\r\n    </ng-template>\r\n  </ng-container>\r\n\r\n  <ng-template #detailView>\r\n    <tk-workspace-detail\r\n      *ngIf=\"selectedWorkspace\"\r\n      [workspace]=\"selectedWorkspace\"\r\n      (back)=\"onBackToList()\">\r\n    </tk-workspace-detail>\r\n  </ng-template>\r\n</div>\r\n", styles: ["@import\"https://fonts.googleapis.com/css2?family=Inter:wght@300;400&display=swap\";.tk-workspaces{font-family:Inter,Helvetica Neue,Helvetica,Arial,sans-serif;color:#000000f2;padding:1.5rem}.tk-workspaces__header{display:flex;align-items:flex-start;justify-content:space-between;gap:1rem;padding-bottom:1rem}.tk-workspaces__title{margin:0;font-size:1.5rem;font-weight:600}.tk-workspaces__tabs{display:flex;align-items:center;gap:.25rem;margin-bottom:1rem}.tk-workspaces__tab{display:inline-flex;align-items:center;gap:.375rem;padding:.5rem .875rem;background:none;border:none;border-radius:6.25rem;font-family:inherit;font-size:1rem;font-weight:500;color:#000000b3;cursor:pointer}.tk-workspaces__tab:hover{background:rgba(0,0,0,.0705882353)}.tk-workspaces__tab--active{background:#C1C1C1;color:#000000f2}.tk-workspaces__tab--active:hover{background:rgba(0,0,0,.3019607843)}.tk-workspaces__tab-icon{height:1.125rem;width:1.125rem;opacity:.6}.tk-workspaces__tab--active .tk-workspaces__tab-icon{opacity:1}.tk-workspaces__placeholder{padding:3rem 1rem;text-align:center;color:#0009}::ng-deep input.blue-input{border:solid .0625rem rgba(0,0,0,.5019607843)!important}::ng-deep input.blue-input:focus{display:flex;align-items:center;color:#000000b3;background-color:#ededed;border:solid .0625rem rgba(0,0,0,.5019607843);font-weight:500;cursor:pointer;flex-wrap:wrap;gap:.5rem;box-shadow:0 0 0 .12rem #fff,0 0 0 .25rem #1170cf,0 0 0 .3rem #1170cf59;background-color:#fff!important}::ng-deep input.blue-input:focus:focus-visible{outline:none}::ng-deep input.blue-input:hover{background-color:#00000012!important}.data-loader{position:absolute;top:calc(50% - 25px);left:calc(50% - 25px)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.APIService }, { type: i2.WorkspacesService }, { type: i3.Location }]; }, propDecorators: { host: [{
+                type: Input
+            }], token: [{
+                type: Input
+            }], customerId: [{
+                type: Input
+            }], addWorkspace: [{
+                type: Output
+            }], openWorkspace: [{
+                type: Output
+            }], editWorkspace: [{
+                type: Output
+            }], deleteWorkspace: [{
+                type: Output
+            }], addDevice: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspaces.component.js","sourceRoot":"","sources":["../../../../../../projects/tuki/widgets/workspaces/src/workspaces.component.ts","../../../../../../projects/tuki/widgets/workspaces/src/workspaces.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Location } from '@angular/common';\r\nimport { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';\r\nimport { APIService } from './services/api.service';\r\nimport { WorkspacesService } from './services/workspaces.service';\r\nimport { Workspace } from './types/workspace';\r\n\r\ntype WorkspacesView = 'list' | 'detail';\r\n\r\ntype WorkspacesTab = 'workspaces' | 'insights' | 'integrations' | 'settings';\r\n\r\ninterface WorkspacesTabDefinition {\r\n  id: WorkspacesTab;\r\n  label: string;\r\n  icon: string;\r\n}\r\n\r\n@Component({\r\n  selector: 'tk-workspaces',\r\n  templateUrl: './workspaces.component.html',\r\n  styleUrls: ['./workspaces.component.scss'],\r\n})\r\nexport class WorkspacesComponent implements OnInit {\r\n  @Input() host!: string;\r\n  @Input() token!: string;\r\n  @Input() customerId!: string;\r\n\r\n  @Output() addWorkspace = new EventEmitter<void>();\r\n  @Output() openWorkspace = new EventEmitter<string>();\r\n  @Output() editWorkspace = new EventEmitter<string>();\r\n  @Output() deleteWorkspace = new EventEmitter<string>();\r\n  @Output() addDevice = new EventEmitter<string>();\r\n\r\n  readonly tabs: WorkspacesTabDefinition[] = [\r\n    { id: 'workspaces', label: 'Workspaces', icon: 'assets/icons/device-in-room-regular.svg' },\r\n    { id: 'insights', label: 'Insights', icon: 'assets/icons/analysis-regular.svg' },\r\n    { id: 'integrations', label: 'Integrations', icon: 'assets/icons/integrations-regular.svg' },\r\n    { id: 'settings', label: 'Settings', icon: 'assets/icons/tools-regular.svg' },\r\n  ];\r\n\r\n  activeTab: WorkspacesTab = 'workspaces';\r\n\r\n  view: WorkspacesView = 'list';\r\n  selectedWorkspace: Workspace | null = null;\r\n\r\n  workspaces: Workspace[] = [];\r\n  isLoading = false;\r\n\r\n  pageIndex = 0;\r\n  pageSize = 10;\r\n  total = 0;\r\n\r\n  searchTerm = '';\r\n  typeFilter = '';\r\n  locationFilter = '';\r\n\r\n  constructor(\r\n    private apiService: APIService,\r\n    private workspacesService: WorkspacesService,\r\n    private location: Location,\r\n  ) { }\r\n\r\n  ngOnInit(): void {\r\n    this.apiService.token = this.token;\r\n    this.apiService.apiUrl = this.host + '/dcp';\r\n    this.fetchWorkspaces();\r\n  }\r\n\r\n  get typeOptions(): string[] {\r\n    return [...new Set(this.workspaces.map(workspace => workspace.typeLabel).filter(Boolean))];\r\n  }\r\n\r\n  get locationOptions(): string[] {\r\n    return [...new Set(this.workspaces.map(workspace => workspace.location).filter(Boolean))];\r\n  }\r\n\r\n  get filteredWorkspaces(): Workspace[] {\r\n    const term = this.searchTerm.trim().toLowerCase();\r\n    return this.workspaces.filter(workspace =>\r\n      (!term || workspace.displayName.toLowerCase().includes(term) || workspace.location.toLowerCase().includes(term)) &&\r\n      (!this.typeFilter || workspace.typeLabel === this.typeFilter) &&\r\n      (!this.locationFilter || workspace.location === this.locationFilter)\r\n    );\r\n  }\r\n\r\n  selectTab(tab: WorkspacesTab): void {\r\n    this.activeTab = tab;\r\n  }\r\n\r\n  onOpenWorkspace(id: string): void {\r\n    const workspace = this.workspaces.find(item => item.id === id) ?? null;\r\n    this.openWorkspace.emit(id);\r\n\r\n    if (!workspace) {\r\n      return;\r\n    }\r\n\r\n    this.selectedWorkspace = workspace;\r\n    this.view = 'detail';\r\n  }\r\n\r\n  onBackToList(): void {\r\n    this.view = 'list';\r\n    this.selectedWorkspace = null;\r\n    this.location.replaceState('/workspaces');\r\n  }\r\n\r\n  onSearchChange(term: string): void {\r\n    this.searchTerm = term;\r\n  }\r\n\r\n  onTypeFilterChange(type: string): void {\r\n    this.typeFilter = type;\r\n  }\r\n\r\n  onLocationFilterChange(location: string): void {\r\n    this.locationFilter = location;\r\n  }\r\n\r\n  onPageChange({ pageIndex, pageSize }: { pageIndex: number; pageSize: number }): void {\r\n    this.pageIndex = pageIndex;\r\n    this.pageSize = pageSize;\r\n    this.fetchWorkspaces();\r\n  }\r\n\r\n  private fetchWorkspaces(): void {\r\n    this.isLoading = true;\r\n    this.workspacesService.fetchWorkspaces(this.customerId, this.pageSize, this.pageIndex).subscribe({\r\n      next: ({ workspaces, total }) => {\r\n        this.workspaces = workspaces;\r\n        this.total = total;\r\n        this.isLoading = false;\r\n      },\r\n      error: () => {\r\n        this.workspaces = [];\r\n        this.total = 0;\r\n        this.isLoading = false;\r\n      },\r\n    });\r\n  }\r\n}\r\n","<div class=\"tk-workspaces\">\r\n  <ng-container *ngIf=\"view === 'list'; else detailView\">\r\n    <header class=\"tk-workspaces__header\">\r\n      <h1 class=\"tk-workspaces__title\">Workspaces</h1>\r\n    </header>\r\n\r\n    <nav class=\"tk-workspaces__tabs\">\r\n      <button\r\n        type=\"button\"\r\n        *ngFor=\"let tab of tabs\"\r\n        class=\"tk-workspaces__tab\"\r\n        [class.tk-workspaces__tab--active]=\"activeTab === tab.id\"\r\n        (click)=\"selectTab(tab.id)\">\r\n        <img class=\"tk-workspaces__tab-icon\" [src]=\"tab.icon\" alt=\"\" />\r\n        {{ tab.label }}\r\n      </button>\r\n    </nav>\r\n\r\n    <ng-container *ngIf=\"activeTab === 'workspaces'; else placeholder\">\r\n      <app-loader *ngIf=\"isLoading\"></app-loader>\r\n\r\n      <tk-workspaces-filters\r\n        [resultCount]=\"total\"\r\n        [typeOptions]=\"typeOptions\"\r\n        [locationOptions]=\"locationOptions\"\r\n        (searchChange)=\"onSearchChange($event)\"\r\n        (typeChange)=\"onTypeFilterChange($event)\"\r\n        (locationChange)=\"onLocationFilterChange($event)\"\r\n        (addWorkspace)=\"addWorkspace.emit()\">\r\n      </tk-workspaces-filters>\r\n\r\n      <tk-workspaces-table\r\n        [workspaces]=\"filteredWorkspaces\"\r\n        [total]=\"total\"\r\n        [pageIndex]=\"pageIndex\"\r\n        [pageSize]=\"pageSize\"\r\n        (openWorkspace)=\"onOpenWorkspace($event)\"\r\n        (editWorkspace)=\"editWorkspace.emit($event)\"\r\n        (deleteWorkspace)=\"deleteWorkspace.emit($event)\"\r\n        (addDevice)=\"addDevice.emit($event)\"\r\n        (pageChange)=\"onPageChange($event)\">\r\n      </tk-workspaces-table>\r\n    </ng-container>\r\n\r\n    <ng-template #placeholder>\r\n      <div class=\"tk-workspaces__placeholder\">This section isn't available in this widget yet.</div>\r\n    </ng-template>\r\n  </ng-container>\r\n\r\n  <ng-template #detailView>\r\n    <tk-workspace-detail\r\n      *ngIf=\"selectedWorkspace\"\r\n      [workspace]=\"selectedWorkspace\"\r\n      (back)=\"onBackToList()\">\r\n    </tk-workspace-detail>\r\n  </ng-template>\r\n</div>\r\n"]}

package/esm2020/workspaces/src/workspaces.module.mjs

@@ -0,0 +1,48 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { HttpClientModule } from '@angular/common/http';
+import { FormsModule } from '@angular/forms';
+import { MaterialModule } from './material.module';
+import { WorkspacesComponent } from './workspaces.component';
+import { WorkspacesFiltersComponent } from './components/workspaces-filters/workspaces-filters.component';
+import { WorkspacesTableComponent } from './components/workspaces-table/workspaces-table.component';
+import { WorkspaceDetailComponent } from './components/workspace-detail/workspace-detail.component';
+import { AppLoaderComponent } from './utils/app-loader/app-loader';
+import * as i0 from "@angular/core";
+export class WorkspacesModule {
+}
+WorkspacesModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspacesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+WorkspacesModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: WorkspacesModule, declarations: [WorkspacesComponent,
+        WorkspacesFiltersComponent,
+        WorkspacesTableComponent,
+        WorkspaceDetailComponent,
+        AppLoaderComponent], imports: [CommonModule,
+        HttpClientModule,
+        FormsModule,
+        MaterialModule], exports: [WorkspacesComponent] });
+WorkspacesModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspacesModule, imports: [CommonModule,
+        HttpClientModule,
+        FormsModule,
+        MaterialModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WorkspacesModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        WorkspacesComponent,
+                        WorkspacesFiltersComponent,
+                        WorkspacesTableComponent,
+                        WorkspaceDetailComponent,
+                        AppLoaderComponent,
+                    ],
+                    imports: [
+                        CommonModule,
+                        HttpClientModule,
+                        FormsModule,
+                        MaterialModule,
+                    ],
+                    exports: [
+                        WorkspacesComponent,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/workspaces/tuki-io-tuki-widgets-workspaces.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHVraS1pby10dWtpLXdpZGdldHMtd29ya3NwYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R1a2kvd2lkZ2V0cy93b3Jrc3BhY2VzL3R1a2ktaW8tdHVraS13aWRnZXRzLXdvcmtzcGFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==