@alfresco/aca-content 5.1.1 → 5.2.0

package/esm2022/folder-rules/services/folder-rules.service.mjs

@@ -0,0 +1,195 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { Injectable } from '@angular/core';
+import { AlfrescoApiService } from '@alfresco/adf-content-services';
+import { BehaviorSubject, from } from 'rxjs';
+import { finalize, map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-content-services";
+class FolderRulesService {
+    apiService;
+    static MAX_RULES_PER_GET = 100;
+    static get emptyCompositeCondition() {
+        return {
+            inverted: false,
+            booleanMode: 'and',
+            compositeConditions: [],
+            simpleConditions: []
+        };
+    }
+    static get emptyRuleOptions() {
+        return {
+            isEnabled: true,
+            isInheritable: false,
+            isAsynchronous: false,
+            errorScript: ''
+        };
+    }
+    static get emptyRule() {
+        return {
+            id: '',
+            name: '',
+            description: '',
+            isShared: false,
+            triggers: ['inbound'],
+            conditions: FolderRulesService.emptyCompositeCondition,
+            actions: [],
+            ...FolderRulesService.emptyRuleOptions
+        };
+    }
+    static get emptyRuleForForm() {
+        const value = {
+            ...FolderRulesService.emptyRule,
+            options: FolderRulesService.emptyRuleOptions
+        };
+        Object.keys(value.options).forEach((key) => {
+            delete value[key];
+        });
+        return value;
+    }
+    selectedRuleSource = new BehaviorSubject(null);
+    deletedRuleIdSource = new BehaviorSubject(null);
+    selectedRule$ = this.selectedRuleSource.asObservable();
+    deletedRuleId$ = this.deletedRuleIdSource.asObservable();
+    constructor(apiService) {
+        this.apiService = apiService;
+    }
+    callApi(path, httpMethod, body = {}) {
+        // APIs used by this service are still private and not yet available for public use
+        const params = [{}, {}, {}, {}, body, ['application/json'], ['application/json']];
+        return this.apiService.getInstance().contentPrivateClient.callApi(path, httpMethod, ...params);
+    }
+    getRules(owningFolderId, ruleSetId, skipCount = 0) {
+        return from(this.callApi(`/nodes/${owningFolderId}/rule-sets/${ruleSetId}/rules?skipCount=${skipCount}&maxItems=${FolderRulesService.MAX_RULES_PER_GET}`, 'GET')).pipe(map((res) => ({
+            rules: this.formatRules(res),
+            hasMoreRules: !!res?.list?.pagination?.hasMoreItems
+        })));
+    }
+    loadRules(ruleSet, skipCount = ruleSet.rules.length, selectRule = null) {
+        if (ruleSet && !ruleSet.loadingRules) {
+            ruleSet.loadingRules = true;
+            this.getRules(ruleSet.owningFolder.id, ruleSet.id, skipCount)
+                .pipe(finalize(() => {
+                ruleSet.loadingRules = false;
+            }))
+                .subscribe((res) => {
+                ruleSet.hasMoreRules = res.hasMoreRules;
+                ruleSet.rules.splice(skipCount);
+                ruleSet.rules.push(...res.rules);
+                this.selectRuleInRuleSet(ruleSet, selectRule);
+            });
+        }
+    }
+    async createRule(nodeId, rule, ruleSetId = '-default-') {
+        const response = await this.callApi(`/nodes/${nodeId}/rule-sets/${ruleSetId}/rules`, 'POST', { ...rule });
+        return this.formatRule(response.entry);
+    }
+    async updateRule(nodeId, ruleId, rule, ruleSetId = '-default-') {
+        const response = await this.callApi(`/nodes/${nodeId}/rule-sets/${ruleSetId}/rules/${ruleId}`, 'PUT', { ...rule });
+        return this.formatRule(response.entry);
+    }
+    deleteRule(nodeId, ruleId, ruleSetId = '-default-') {
+        from(this.callApi(`/nodes/${nodeId}/rule-sets/${ruleSetId}/rules/${ruleId}`, 'DELETE')).subscribe(() => {
+            this.deletedRuleIdSource.next(ruleId);
+        }, (error) => {
+            this.deletedRuleIdSource.next(error);
+        });
+    }
+    async getRuleSettings(nodeId, key = '-isInheritanceEnabled-') {
+        const response = await this.callApi(`/nodes/${nodeId}/rule-settings/${key}`, 'GET');
+        return response.entry;
+    }
+    async updateRuleSettings(nodeId, key, body) {
+        const response = await this.callApi(`/nodes/${nodeId}/rule-settings/${key}`, 'PUT', { ...body });
+        return response.entry;
+    }
+    formatRules(res) {
+        return [...res.list.entries.map((entry) => this.formatRule(entry.entry))];
+    }
+    formatRule(obj) {
+        return {
+            id: obj.id,
+            name: obj.name ?? FolderRulesService.emptyRule.name,
+            description: obj.description ?? FolderRulesService.emptyRule.description,
+            isEnabled: obj.isEnabled ?? FolderRulesService.emptyRule.isEnabled,
+            isInheritable: obj.isInheritable ?? FolderRulesService.emptyRule.isInheritable,
+            isAsynchronous: obj.isAsynchronous ?? FolderRulesService.emptyRule.isAsynchronous,
+            errorScript: obj.errorScript ?? FolderRulesService.emptyRule.errorScript,
+            isShared: obj.isShared ?? FolderRulesService.emptyRule.isShared,
+            triggers: obj.triggers ?? FolderRulesService.emptyRule.triggers,
+            conditions: this.formatCompositeCondition(obj.conditions ?? { ...FolderRulesService.emptyRule.conditions }),
+            actions: obj.actions ?? FolderRulesService.emptyRule.actions
+        };
+    }
+    formatCompositeCondition(obj) {
+        return {
+            inverted: obj.inverted ?? false,
+            booleanMode: obj.booleanMode ?? 'and',
+            compositeConditions: (obj.compositeConditions || []).map((condition) => this.formatCompositeCondition(condition)),
+            simpleConditions: this.parseSimpleCondition(obj.simpleConditions)
+        };
+    }
+    parseSimpleCondition(arr) {
+        if (arr) {
+            if (arr.every((element) => element === null)) {
+                return [];
+            }
+            return arr.map((condition) => this.formatSimpleCondition(condition));
+        }
+        else {
+            return [];
+        }
+    }
+    formatSimpleCondition(obj) {
+        return {
+            field: obj.field || 'cm:name',
+            comparator: obj.comparator || 'equals',
+            parameter: obj.parameter || ''
+        };
+    }
+    selectRule(rule) {
+        this.selectedRuleSource.next(rule);
+    }
+    selectRuleInRuleSet(ruleSet, selectRule = null) {
+        if (selectRule === 'first') {
+            this.selectRule(ruleSet.rules[0]);
+        }
+        else if (selectRule === 'last') {
+            this.selectRule(ruleSet.rules[ruleSet.rules.length - 1]);
+        }
+        else if (selectRule) {
+            this.selectRule(selectRule);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: FolderRulesService, deps: [{ token: i1.AlfrescoApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: FolderRulesService, providedIn: 'root' });
+}
+export { FolderRulesService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: FolderRulesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AlfrescoApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"folder-rules.service.js","sourceRoot":"","sources":["../../../../../../projects/aca-content/folder-rules/src/services/folder-rules.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail. Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { Injectable } from '@angular/core';\nimport { AlfrescoApiService } from '@alfresco/adf-content-services';\nimport { BehaviorSubject, from, Observable } from 'rxjs';\nimport { finalize, map } from 'rxjs/operators';\nimport { Rule, RuleForForm, RuleOptions, RuleSettings } from '../model/rule.model';\nimport { RuleCompositeCondition } from '../model/rule-composite-condition.model';\nimport { RuleSimpleCondition } from '../model/rule-simple-condition.model';\nimport { RuleSet } from '../model/rule-set.model';\n\ninterface GetRulesResult {\n  rules: Rule[];\n  hasMoreRules: boolean;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class FolderRulesService {\n  public static readonly MAX_RULES_PER_GET = 100;\n\n  public static get emptyCompositeCondition(): RuleCompositeCondition {\n    return {\n      inverted: false,\n      booleanMode: 'and',\n      compositeConditions: [],\n      simpleConditions: []\n    };\n  }\n\n  public static get emptyRuleOptions(): RuleOptions {\n    return {\n      isEnabled: true,\n      isInheritable: false,\n      isAsynchronous: false,\n      errorScript: ''\n    };\n  }\n\n  public static get emptyRule(): Rule {\n    return {\n      id: '',\n      name: '',\n      description: '',\n      isShared: false,\n      triggers: ['inbound'],\n      conditions: FolderRulesService.emptyCompositeCondition,\n      actions: [],\n      ...FolderRulesService.emptyRuleOptions\n    };\n  }\n\n  public static get emptyRuleForForm(): RuleForForm {\n    const value = {\n      ...FolderRulesService.emptyRule,\n      options: FolderRulesService.emptyRuleOptions\n    };\n    Object.keys(value.options).forEach((key: string) => {\n      delete value[key];\n    });\n    return value;\n  }\n\n  private selectedRuleSource = new BehaviorSubject<Rule>(null);\n  private deletedRuleIdSource = new BehaviorSubject<string>(null);\n\n  selectedRule$ = this.selectedRuleSource.asObservable();\n  deletedRuleId$: Observable<string> = this.deletedRuleIdSource.asObservable();\n\n  constructor(private apiService: AlfrescoApiService) {}\n\n  private callApi(path: string, httpMethod: string, body: object = {}): Promise<any> {\n    // APIs used by this service are still private and not yet available for public use\n    const params = [{}, {}, {}, {}, body, ['application/json'], ['application/json']];\n    return this.apiService.getInstance().contentPrivateClient.callApi(path, httpMethod, ...params);\n  }\n\n  getRules(owningFolderId: string, ruleSetId: string, skipCount = 0): Observable<GetRulesResult> {\n    return from(\n      this.callApi(\n        `/nodes/${owningFolderId}/rule-sets/${ruleSetId}/rules?skipCount=${skipCount}&maxItems=${FolderRulesService.MAX_RULES_PER_GET}`,\n        'GET'\n      )\n    ).pipe(\n      map((res) => ({\n        rules: this.formatRules(res),\n        hasMoreRules: !!res?.list?.pagination?.hasMoreItems\n      }))\n    );\n  }\n\n  loadRules(ruleSet: RuleSet, skipCount = ruleSet.rules.length, selectRule: 'first' | 'last' | Rule = null) {\n    if (ruleSet && !ruleSet.loadingRules) {\n      ruleSet.loadingRules = true;\n      this.getRules(ruleSet.owningFolder.id, ruleSet.id, skipCount)\n        .pipe(\n          finalize(() => {\n            ruleSet.loadingRules = false;\n          })\n        )\n        .subscribe((res: GetRulesResult) => {\n          ruleSet.hasMoreRules = res.hasMoreRules;\n          ruleSet.rules.splice(skipCount);\n          ruleSet.rules.push(...res.rules);\n          this.selectRuleInRuleSet(ruleSet, selectRule);\n        });\n    }\n  }\n\n  async createRule(nodeId: string, rule: Partial<Rule>, ruleSetId: string = '-default-'): Promise<Rule> {\n    const response = await this.callApi(`/nodes/${nodeId}/rule-sets/${ruleSetId}/rules`, 'POST', { ...rule });\n    return this.formatRule(response.entry);\n  }\n\n  async updateRule(nodeId: string, ruleId: string, rule: Rule, ruleSetId: string = '-default-'): Promise<Rule> {\n    const response = await this.callApi(`/nodes/${nodeId}/rule-sets/${ruleSetId}/rules/${ruleId}`, 'PUT', { ...rule });\n    return this.formatRule(response.entry);\n  }\n\n  deleteRule(nodeId: string, ruleId: string, ruleSetId: string = '-default-') {\n    from(this.callApi(`/nodes/${nodeId}/rule-sets/${ruleSetId}/rules/${ruleId}`, 'DELETE')).subscribe(\n      () => {\n        this.deletedRuleIdSource.next(ruleId);\n      },\n      (error) => {\n        this.deletedRuleIdSource.next(error);\n      }\n    );\n  }\n\n  async getRuleSettings(nodeId: string, key: string = '-isInheritanceEnabled-'): Promise<RuleSettings> {\n    const response = await this.callApi(`/nodes/${nodeId}/rule-settings/${key}`, 'GET');\n    return response.entry;\n  }\n\n  async updateRuleSettings(nodeId: string, key: string, body: RuleSettings): Promise<RuleSettings> {\n    const response = await this.callApi(`/nodes/${nodeId}/rule-settings/${key}`, 'PUT', { ...body });\n    return response.entry;\n  }\n\n  private formatRules(res): Rule[] {\n    return [...res.list.entries.map((entry) => this.formatRule(entry.entry))];\n  }\n\n  private formatRule(obj): Rule {\n    return {\n      id: obj.id,\n      name: obj.name ?? FolderRulesService.emptyRule.name,\n      description: obj.description ?? FolderRulesService.emptyRule.description,\n      isEnabled: obj.isEnabled ?? FolderRulesService.emptyRule.isEnabled,\n      isInheritable: obj.isInheritable ?? FolderRulesService.emptyRule.isInheritable,\n      isAsynchronous: obj.isAsynchronous ?? FolderRulesService.emptyRule.isAsynchronous,\n      errorScript: obj.errorScript ?? FolderRulesService.emptyRule.errorScript,\n      isShared: obj.isShared ?? FolderRulesService.emptyRule.isShared,\n      triggers: obj.triggers ?? FolderRulesService.emptyRule.triggers,\n      conditions: this.formatCompositeCondition(obj.conditions ?? { ...FolderRulesService.emptyRule.conditions }),\n      actions: obj.actions ?? FolderRulesService.emptyRule.actions\n    };\n  }\n\n  private formatCompositeCondition(obj): RuleCompositeCondition {\n    return {\n      inverted: obj.inverted ?? false,\n      booleanMode: obj.booleanMode ?? 'and',\n      compositeConditions: (obj.compositeConditions || []).map((condition) => this.formatCompositeCondition(condition)),\n      simpleConditions: this.parseSimpleCondition(obj.simpleConditions)\n    };\n  }\n\n  private parseSimpleCondition(arr) {\n    if (arr) {\n      if (arr.every((element) => element === null)) {\n        return [];\n      }\n      return arr.map((condition) => this.formatSimpleCondition(condition));\n    } else {\n      return [];\n    }\n  }\n\n  private formatSimpleCondition(obj): RuleSimpleCondition {\n    return {\n      field: obj.field || 'cm:name',\n      comparator: obj.comparator || 'equals',\n      parameter: obj.parameter || ''\n    };\n  }\n\n  selectRule(rule: Rule) {\n    this.selectedRuleSource.next(rule);\n  }\n\n  selectRuleInRuleSet(ruleSet: RuleSet, selectRule: 'first' | 'last' | Rule = null) {\n    if (selectRule === 'first') {\n      this.selectRule(ruleSet.rules[0]);\n    } else if (selectRule === 'last') {\n      this.selectRule(ruleSet.rules[ruleSet.rules.length - 1]);\n    } else if (selectRule) {\n      this.selectRule(selectRule);\n    }\n  }\n}\n"]}

package/esm2022/lib/aca-content.module.mjs

@@ -0,0 +1,303 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { HammerModule } from '@angular/platform-browser';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { AuthGuardEcm, LanguagePickerComponent, NotificationHistoryComponent, TRANSLATION_PROVIDER } from '@alfresco/adf-core';
+import { ContentModule, ContentVersionService, LibraryNameColumnComponent, LibraryRoleColumnComponent, LibraryStatusColumnComponent, TrashcanNameColumnComponent } from '@alfresco/adf-content-services';
+import { DocumentBasePageService, ExtensionsDataLoaderGuard, OpenInAppComponent } from '@alfresco/aca-shared';
+import * as rules from '@alfresco/aca-shared/rules';
+import { AppStoreModule } from './store/app-store.module';
+import { CoreExtensionsModule } from './extensions/core.extensions.module';
+import { AppInfoDrawerModule } from './components/info-drawer/info.drawer.module';
+import { ExtensionService, ExtensionsModule } from '@alfresco/adf-extensions';
+import { APP_TOOLBAR_DIRECTIVES } from './components/toolbar';
+import { APP_SIDENAV_DIRECTIVES } from './components/sidenav';
+import { APP_COMMON_DIRECTIVES } from './components/common';
+import { APP_SEARCH_DIRECTIVES } from './components/search';
+import { CreateFromTemplateDialogComponent } from './dialogs/node-template/create-from-template.dialog';
+import { ContentUrlService } from './services/content-url.service';
+import { CommonModule } from '@angular/common';
+import { LocationLinkComponent } from './components/common/location-link/location-link.component';
+import { LogoutComponent } from './components/common/logout/logout.component';
+import { ToggleSharedComponent } from './components/common/toggle-shared/toggle-shared.component';
+import { CustomNameColumnComponent } from './components/dl-custom-components/name-column/name-column.component';
+import { CommentsTabComponent } from './components/info-drawer/comments-tab/comments-tab.component';
+import { LibraryMetadataTabComponent } from './components/info-drawer/library-metadata-tab/library-metadata-tab.component';
+import { MetadataTabComponent } from './components/info-drawer/metadata-tab/metadata-tab.component';
+import { VersionsTabComponent } from './components/info-drawer/versions-tab/versions-tab.component';
+import { PreviewComponent } from '@alfresco/aca-content/viewer';
+import { ToggleEditOfflineComponent } from './components/toolbar/toggle-edit-offline/toggle-edit-offline.component';
+import { ToggleFavoriteLibraryComponent } from './components/toolbar/toggle-favorite-library/toggle-favorite-library.component';
+import { ToggleFavoriteComponent } from './components/toolbar/toggle-favorite/toggle-favorite.component';
+import { ToggleInfoDrawerComponent } from './components/toolbar/toggle-info-drawer/toggle-info-drawer.component';
+import { ToggleJoinLibraryButtonComponent } from './components/toolbar/toggle-join-library/toggle-join-library-button.component';
+import { ToggleJoinLibraryMenuComponent } from './components/toolbar/toggle-join-library/toggle-join-library-menu.component';
+import { ViewNodeComponent } from './components/toolbar/view-node/view-node.component';
+import { CONTENT_ROUTES } from './aca-content.routes';
+import { RouterModule } from '@angular/router';
+import { UploadFilesDialogComponent } from './components/upload-files-dialog/upload-files-dialog.component';
+import { AcaFolderRulesModule } from '@alfresco/aca-content/folder-rules';
+import { TagsColumnComponent } from './components/dl-custom-components/tags-column/tags-column.component';
+import { UserInfoComponent } from './components/common/user-info/user-info.component';
+import { SidenavComponent } from './components/sidenav/sidenav.component';
+import { ContentManagementService } from './services/content-management.service';
+import { SHELL_NAVBAR_MIN_WIDTH, ShellLayoutComponent } from '@alfresco/adf-core/shell';
+import { UserMenuComponent } from './components/sidenav/user-menu/user-menu.component';
+import { ContextMenuComponent } from './components/context-menu/context-menu.component';
+import { MAT_DIALOG_DEFAULT_OPTIONS } from '@angular/material/dialog';
+import { SearchResultsRowComponent } from './components/search/search-results-row/search-results-row.component';
+import { BulkActionsDropdownComponent } from './components/bulk-actions-dropdown/bulk-actions-dropdown.component';
+import { AgentsButtonComponent } from './components/knowledge-retrieval/search-ai/agents-button/agents-button.component';
+import { SaveSearchSidenavComponent } from './components/search/search-save/sidenav/save-search-sidenav.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-extensions";
+import * as i2 from "@alfresco/adf-content-services";
+import * as i3 from "@angular/router";
+import * as i4 from "./components/common/language-picker/language-picker.component";
+import * as i5 from "./components/common/location-link/location-link.component";
+import * as i6 from "./components/common/logout/logout.component";
+import * as i7 from "./components/common/toggle-shared/toggle-shared.component";
+import * as i8 from "./components/common/user-info/user-info.component";
+import * as i9 from "./components/toolbar/toggle-favorite/toggle-favorite.component";
+import * as i10 from "./components/toolbar/toggle-edit-offline/toggle-edit-offline.component";
+import * as i11 from "./components/toolbar/toggle-info-drawer/toggle-info-drawer.component";
+import * as i12 from "./components/toolbar/toggle-join-library/toggle-join-library-button.component";
+import * as i13 from "./components/toolbar/toggle-join-library/toggle-join-library-menu.component";
+import * as i14 from "./components/toolbar/toggle-favorite-library/toggle-favorite-library.component";
+import * as i15 from "./components/toolbar/view-node/view-node.component";
+import * as i16 from "./components/sidenav/components/button-menu.component";
+import * as i17 from "./components/sidenav/directives/active-link.directive";
+import * as i18 from "./components/sidenav/directives/action.directive";
+import * as i19 from "./components/sidenav/directives/menu-panel.directive";
+import * as i20 from "./components/sidenav/components/expand-menu.component";
+import * as i21 from "./components/sidenav/directives/expansion-panel.directive";
+import * as i22 from "./components/sidenav/components/sidenav-header.component";
+import * as i23 from "./components/sidenav/user-menu/user-menu.component";
+import * as i24 from "./components/sidenav/sidenav.component";
+import * as i25 from "./components/search/search-action-menu/search-action-menu.component";
+import * as i26 from "./components/search/search-libraries-results/search-libraries-results.component";
+import * as i27 from "./components/search/search-results/search-results.component";
+import * as i28 from "./components/search/search-results-row/search-results-row.component";
+import * as i29 from "./components/search/search-input/search-input.component";
+import * as i30 from "./components/search/search-input-control/search-input-control.component";
+class ContentServiceExtensionModule {
+    extensions;
+    constructor(extensions) {
+        this.extensions = extensions;
+        extensions.setAuthGuards({
+            'app.auth': AuthGuardEcm,
+            'app.extensions.dataLoaderGuard': ExtensionsDataLoaderGuard
+        });
+        extensions.setComponents({
+            'app.layout.main': ShellLayoutComponent,
+            'app.layout.sidenav': SidenavComponent,
+            'app.shell.sibling': UploadFilesDialogComponent,
+            'app.components.tabs.metadata': MetadataTabComponent,
+            'app.components.tabs.library.metadata': LibraryMetadataTabComponent,
+            'app.components.tabs.comments': CommentsTabComponent,
+            'app.components.tabs.versions': VersionsTabComponent,
+            'app.components.preview': PreviewComponent,
+            'app.toolbar.toggleInfoDrawer': ToggleInfoDrawerComponent,
+            'app.toolbar.toggleFavorite': ToggleFavoriteComponent,
+            'app.toolbar.toggleFavoriteLibrary': ToggleFavoriteLibraryComponent,
+            'app.toolbar.toggleJoinLibrary': ToggleJoinLibraryButtonComponent,
+            'app.toolbar.ai.agents-button': AgentsButtonComponent,
+            'app.menu.toggleJoinLibrary': ToggleJoinLibraryMenuComponent,
+            'app.bulk-actions-dropdown': BulkActionsDropdownComponent,
+            'app.shared-link.toggleSharedLink': ToggleSharedComponent,
+            'app.columns.name': CustomNameColumnComponent,
+            'app.columns.libraryName': LibraryNameColumnComponent,
+            'app.columns.libraryRole': LibraryRoleColumnComponent,
+            'app.columns.libraryStatus': LibraryStatusColumnComponent,
+            'app.columns.trashcanName': TrashcanNameColumnComponent,
+            'app.columns.location': LocationLinkComponent,
+            'app.columns.tags': TagsColumnComponent,
+            'app.toolbar.toggleEditOffline': ToggleEditOfflineComponent,
+            'app.toolbar.viewNode': ViewNodeComponent,
+            'app.languagePicker': LanguagePickerComponent,
+            'app.logout': LogoutComponent,
+            'app.user': UserInfoComponent,
+            'app.notification-center': NotificationHistoryComponent,
+            'app.user.menu': UserMenuComponent,
+            'app.search.columns.name': SearchResultsRowComponent,
+            'app.search.navbar': SaveSearchSidenavComponent
+        });
+        extensions.setEvaluators({
+            canCopyNode: rules.canCopyNode,
+            canToggleJoinLibrary: rules.canToggleJoinLibrary,
+            canEditFolder: rules.canEditFolder,
+            isTrashcanItemSelected: rules.isTrashcanItemSelected,
+            canViewFile: rules.canViewFile,
+            canLeaveLibrary: rules.canLeaveLibrary,
+            canToggleSharedLink: rules.canToggleSharedLink,
+            canShowInfoDrawer: rules.canShowInfoDrawer,
+            canManageFileVersions: rules.canManageFileVersions,
+            canManagePermissions: rules.canManagePermissions,
+            canToggleEditOffline: rules.canToggleEditOffline,
+            canToggleFavorite: rules.canToggleFavorite,
+            isLibraryManager: rules.isLibraryManager,
+            canEditAspects: rules.canEditAspects,
+            canShowExpand: rules.canShowExpand,
+            canInfoPreview: rules.canInfoPreview,
+            'app.selection.canDelete': rules.canDeleteSelection,
+            'app.selection.file.canUnlock': rules.canUnlockFile,
+            'app.selection.file.canLock': rules.canLockFile,
+            'app.selection.canDownload': rules.canDownloadSelection,
+            'app.selection.notEmpty': rules.hasSelection,
+            'app.selection.canUnshare': rules.canUnshareNodes,
+            'app.selection.canAddFavorite': rules.canAddFavorite,
+            'app.selection.canRemoveFavorite': rules.canRemoveFavorite,
+            'app.selection.first.canUpdate': rules.canUpdateSelectedNode,
+            'app.selection.file': rules.hasFileSelected,
+            'app.selection.file.canShare': rules.canShareFile,
+            'app.selection.file.isShared': rules.isShared,
+            'app.selection.file.isLocked': rules.hasLockedFiles,
+            'app.selection.file.isLockOwner': rules.isUserWriteLockOwner,
+            'app.selection.file.canUploadVersion': rules.canUploadVersion,
+            'app.selection.library': rules.hasLibrarySelected,
+            'app.selection.isPrivateLibrary': rules.isPrivateLibrary,
+            'app.selection.hasLibraryRole': rules.hasLibraryRole,
+            'app.selection.hasNoLibraryRole': rules.hasNoLibraryRole,
+            'app.selection.folder': rules.hasFolderSelected,
+            'app.selection.folder.canUpdate': rules.canUpdateSelectedFolder,
+            'app.selection.displayedKnowledgeRetrievalButton': rules.canDisplayKnowledgeRetrievalButton,
+            'app.navigation.folder.canCreate': rules.canCreateFolder,
+            'app.navigation.folder.canUpload': rules.canUpload,
+            'app.navigation.isTrashcan': rules.isTrashcan,
+            'app.navigation.isNotTrashcan': rules.isNotTrashcan,
+            'app.navigation.isLibraries': rules.isLibraries,
+            'app.navigation.isLibraryFiles': rules.isLibraryFiles,
+            'app.navigation.isPersonalFiles': rules.isPersonalFiles,
+            'app.navigation.isNotLibraries': rules.isNotLibraries,
+            'app.navigation.isSharedFiles': rules.isSharedFiles,
+            'app.navigation.isNotSharedFiles': rules.isNotSharedFiles,
+            'app.navigation.isFavorites': rules.isFavorites,
+            'app.navigation.isNotFavorites': rules.isNotFavorites,
+            'app.navigation.isRecentFiles': rules.isRecentFiles,
+            'app.navigation.isNotRecentFiles': rules.isNotRecentFiles,
+            'app.navigation.isSearchResults': rules.isSearchResults,
+            'app.navigation.isNotSearchResults': rules.isNotSearchResults,
+            'app.navigation.isPreview': rules.isPreview,
+            'app.navigation.isSharedPreview': rules.isSharedPreview,
+            'app.navigation.isFavoritesPreview': rules.isFavoritesPreview,
+            'app.navigation.isSharedFileViewer': rules.isSharedFileViewer,
+            'repository.isQuickShareEnabled': rules.hasQuickShareEnabled,
+            'user.isAdmin': rules.isAdmin,
+            'app.canShowLogout': rules.canShowLogout,
+            'app.isContentServiceEnabled': rules.isContentServiceEnabled,
+            'app.isUploadSupported': rules.isUploadSupported,
+            'app.canCreateLibrary': rules.canCreateLibrary,
+            'app.areTagsEnabled': rules.areTagsEnabled,
+            'app.areCategoriesEnabled': rules.areCategoriesEnabled
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ContentServiceExtensionModule, deps: [{ token: i1.ExtensionService }], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.9", ngImport: i0, type: ContentServiceExtensionModule, imports: [CommonModule,
+            FormsModule,
+            ReactiveFormsModule, i2.ContentModule, i3.RouterModule, ExtensionsModule,
+            CoreExtensionsModule,
+            AppStoreModule, i4.LanguagePickerComponent, i5.LocationLinkComponent, i6.LogoutComponent, i7.ToggleSharedComponent, i8.UserInfoComponent, i9.ToggleFavoriteComponent, i10.ToggleEditOfflineComponent, i11.ToggleInfoDrawerComponent, i12.ToggleJoinLibraryButtonComponent, i13.ToggleJoinLibraryMenuComponent, i14.ToggleFavoriteLibraryComponent, i15.ViewNodeComponent, i16.ButtonMenuComponent, i17.ActiveLinkDirective, i18.ActionDirective, i19.MenuPanelDirective, i20.ExpandMenuComponent, i21.ExpansionPanelDirective, i22.SidenavHeaderComponent, i23.UserMenuComponent, i24.SidenavComponent, i25.SearchActionMenuComponent, i26.SearchLibrariesResultsComponent, i27.SearchResultsComponent, i28.SearchResultsRowComponent, i29.SearchInputComponent, i30.SearchInputControlComponent, ContextMenuComponent,
+            AppInfoDrawerModule,
+            HammerModule,
+            AcaFolderRulesModule,
+            CreateFromTemplateDialogComponent,
+            OpenInAppComponent,
+            UploadFilesDialogComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ContentServiceExtensionModule, providers: [
+            { provide: ContentVersionService, useClass: ContentUrlService },
+            { provide: DocumentBasePageService, useExisting: ContentManagementService },
+            {
+                provide: TRANSLATION_PROVIDER,
+                multi: true,
+                useValue: {
+                    name: 'app',
+                    source: 'assets'
+                }
+            },
+            { provide: SHELL_NAVBAR_MIN_WIDTH, useValue: 0 },
+            {
+                provide: MAT_DIALOG_DEFAULT_OPTIONS,
+                useValue: { closeOnNavigation: true, hasBackdrop: true, autoFocus: true }
+            }
+        ], imports: [CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            ContentModule.forRoot(),
+            RouterModule.forChild(CONTENT_ROUTES),
+            ExtensionsModule,
+            CoreExtensionsModule,
+            AppStoreModule, APP_COMMON_DIRECTIVES, APP_TOOLBAR_DIRECTIVES, i16.ButtonMenuComponent, i20.ExpandMenuComponent, i22.SidenavHeaderComponent, i23.UserMenuComponent, i24.SidenavComponent, APP_SEARCH_DIRECTIVES, ContextMenuComponent,
+            AppInfoDrawerModule,
+            HammerModule,
+            AcaFolderRulesModule,
+            CreateFromTemplateDialogComponent,
+            OpenInAppComponent,
+            UploadFilesDialogComponent] });
+}
+export { ContentServiceExtensionModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: ContentServiceExtensionModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        ContentModule.forRoot(),
+                        RouterModule.forChild(CONTENT_ROUTES),
+                        ExtensionsModule,
+                        CoreExtensionsModule,
+                        AppStoreModule,
+                        ...APP_COMMON_DIRECTIVES,
+                        ...APP_TOOLBAR_DIRECTIVES,
+                        ...APP_SIDENAV_DIRECTIVES,
+                        ...APP_SEARCH_DIRECTIVES,
+                        ContextMenuComponent,
+                        AppInfoDrawerModule,
+                        HammerModule,
+                        AcaFolderRulesModule,
+                        CreateFromTemplateDialogComponent,
+                        OpenInAppComponent,
+                        UploadFilesDialogComponent
+                    ],
+                    providers: [
+                        { provide: ContentVersionService, useClass: ContentUrlService },
+                        { provide: DocumentBasePageService, useExisting: ContentManagementService },
+                        {
+                            provide: TRANSLATION_PROVIDER,
+                            multi: true,
+                            useValue: {
+                                name: 'app',
+                                source: 'assets'
+                            }
+                        },
+                        { provide: SHELL_NAVBAR_MIN_WIDTH, useValue: 0 },
+                        {
+                            provide: MAT_DIALOG_DEFAULT_OPTIONS,
+                            useValue: { closeOnNavigation: true, hasBackdrop: true, autoFocus: true }
+                        }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ExtensionService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aca-content.module.js","sourceRoot":"","sources":["../../../../../projects/aca-content/src/lib/aca-content.module.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail. Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { HammerModule } from '@angular/platform-browser';\nimport { NgModule } from '@angular/core';\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\nimport { AuthGuardEcm, LanguagePickerComponent, NotificationHistoryComponent, TRANSLATION_PROVIDER } from '@alfresco/adf-core';\nimport {\n  ContentModule,\n  ContentVersionService,\n  LibraryNameColumnComponent,\n  LibraryRoleColumnComponent,\n  LibraryStatusColumnComponent,\n  TrashcanNameColumnComponent\n} from '@alfresco/adf-content-services';\nimport { DocumentBasePageService, ExtensionsDataLoaderGuard, OpenInAppComponent } from '@alfresco/aca-shared';\nimport * as rules from '@alfresco/aca-shared/rules';\nimport { AppStoreModule } from './store/app-store.module';\nimport { CoreExtensionsModule } from './extensions/core.extensions.module';\nimport { AppInfoDrawerModule } from './components/info-drawer/info.drawer.module';\nimport { ExtensionService, ExtensionsModule } from '@alfresco/adf-extensions';\nimport { APP_TOOLBAR_DIRECTIVES } from './components/toolbar';\nimport { APP_SIDENAV_DIRECTIVES } from './components/sidenav';\nimport { APP_COMMON_DIRECTIVES } from './components/common';\nimport { APP_SEARCH_DIRECTIVES } from './components/search';\nimport { CreateFromTemplateDialogComponent } from './dialogs/node-template/create-from-template.dialog';\nimport { ContentUrlService } from './services/content-url.service';\nimport { CommonModule } from '@angular/common';\nimport { LocationLinkComponent } from './components/common/location-link/location-link.component';\nimport { LogoutComponent } from './components/common/logout/logout.component';\nimport { ToggleSharedComponent } from './components/common/toggle-shared/toggle-shared.component';\nimport { CustomNameColumnComponent } from './components/dl-custom-components/name-column/name-column.component';\nimport { CommentsTabComponent } from './components/info-drawer/comments-tab/comments-tab.component';\nimport { LibraryMetadataTabComponent } from './components/info-drawer/library-metadata-tab/library-metadata-tab.component';\nimport { MetadataTabComponent } from './components/info-drawer/metadata-tab/metadata-tab.component';\nimport { VersionsTabComponent } from './components/info-drawer/versions-tab/versions-tab.component';\nimport { PreviewComponent } from '@alfresco/aca-content/viewer';\nimport { ToggleEditOfflineComponent } from './components/toolbar/toggle-edit-offline/toggle-edit-offline.component';\nimport { ToggleFavoriteLibraryComponent } from './components/toolbar/toggle-favorite-library/toggle-favorite-library.component';\nimport { ToggleFavoriteComponent } from './components/toolbar/toggle-favorite/toggle-favorite.component';\nimport { ToggleInfoDrawerComponent } from './components/toolbar/toggle-info-drawer/toggle-info-drawer.component';\nimport { ToggleJoinLibraryButtonComponent } from './components/toolbar/toggle-join-library/toggle-join-library-button.component';\nimport { ToggleJoinLibraryMenuComponent } from './components/toolbar/toggle-join-library/toggle-join-library-menu.component';\nimport { ViewNodeComponent } from './components/toolbar/view-node/view-node.component';\nimport { CONTENT_ROUTES } from './aca-content.routes';\nimport { RouterModule } from '@angular/router';\nimport { UploadFilesDialogComponent } from './components/upload-files-dialog/upload-files-dialog.component';\nimport { AcaFolderRulesModule } from '@alfresco/aca-content/folder-rules';\nimport { TagsColumnComponent } from './components/dl-custom-components/tags-column/tags-column.component';\nimport { UserInfoComponent } from './components/common/user-info/user-info.component';\nimport { SidenavComponent } from './components/sidenav/sidenav.component';\nimport { ContentManagementService } from './services/content-management.service';\nimport { SHELL_NAVBAR_MIN_WIDTH, ShellLayoutComponent } from '@alfresco/adf-core/shell';\nimport { UserMenuComponent } from './components/sidenav/user-menu/user-menu.component';\nimport { ContextMenuComponent } from './components/context-menu/context-menu.component';\nimport { MAT_DIALOG_DEFAULT_OPTIONS } from '@angular/material/dialog';\nimport { SearchResultsRowComponent } from './components/search/search-results-row/search-results-row.component';\nimport { BulkActionsDropdownComponent } from './components/bulk-actions-dropdown/bulk-actions-dropdown.component';\nimport { AgentsButtonComponent } from './components/knowledge-retrieval/search-ai/agents-button/agents-button.component';\nimport { SaveSearchSidenavComponent } from './components/search/search-save/sidenav/save-search-sidenav.component';\n\n@NgModule({\n  imports: [\n    CommonModule,\n    FormsModule,\n    ReactiveFormsModule,\n    ContentModule.forRoot(),\n    RouterModule.forChild(CONTENT_ROUTES),\n    ExtensionsModule,\n    CoreExtensionsModule,\n    AppStoreModule,\n    ...APP_COMMON_DIRECTIVES,\n    ...APP_TOOLBAR_DIRECTIVES,\n    ...APP_SIDENAV_DIRECTIVES,\n    ...APP_SEARCH_DIRECTIVES,\n    ContextMenuComponent,\n    AppInfoDrawerModule,\n    HammerModule,\n    AcaFolderRulesModule,\n    CreateFromTemplateDialogComponent,\n    OpenInAppComponent,\n    UploadFilesDialogComponent\n  ],\n  providers: [\n    { provide: ContentVersionService, useClass: ContentUrlService },\n    { provide: DocumentBasePageService, useExisting: ContentManagementService },\n    {\n      provide: TRANSLATION_PROVIDER,\n      multi: true,\n      useValue: {\n        name: 'app',\n        source: 'assets'\n      }\n    },\n    { provide: SHELL_NAVBAR_MIN_WIDTH, useValue: 0 },\n    {\n      provide: MAT_DIALOG_DEFAULT_OPTIONS,\n      useValue: { closeOnNavigation: true, hasBackdrop: true, autoFocus: true }\n    }\n  ]\n})\nexport class ContentServiceExtensionModule {\n  constructor(public extensions: ExtensionService) {\n    extensions.setAuthGuards({\n      'app.auth': AuthGuardEcm,\n      'app.extensions.dataLoaderGuard': ExtensionsDataLoaderGuard\n    });\n\n    extensions.setComponents({\n      'app.layout.main': ShellLayoutComponent,\n      'app.layout.sidenav': SidenavComponent,\n      'app.shell.sibling': UploadFilesDialogComponent,\n      'app.components.tabs.metadata': MetadataTabComponent,\n      'app.components.tabs.library.metadata': LibraryMetadataTabComponent,\n      'app.components.tabs.comments': CommentsTabComponent,\n      'app.components.tabs.versions': VersionsTabComponent,\n      'app.components.preview': PreviewComponent,\n      'app.toolbar.toggleInfoDrawer': ToggleInfoDrawerComponent,\n      'app.toolbar.toggleFavorite': ToggleFavoriteComponent,\n      'app.toolbar.toggleFavoriteLibrary': ToggleFavoriteLibraryComponent,\n      'app.toolbar.toggleJoinLibrary': ToggleJoinLibraryButtonComponent,\n      'app.toolbar.ai.agents-button': AgentsButtonComponent,\n      'app.menu.toggleJoinLibrary': ToggleJoinLibraryMenuComponent,\n      'app.bulk-actions-dropdown': BulkActionsDropdownComponent,\n      'app.shared-link.toggleSharedLink': ToggleSharedComponent,\n      'app.columns.name': CustomNameColumnComponent,\n      'app.columns.libraryName': LibraryNameColumnComponent,\n      'app.columns.libraryRole': LibraryRoleColumnComponent,\n      'app.columns.libraryStatus': LibraryStatusColumnComponent,\n      'app.columns.trashcanName': TrashcanNameColumnComponent,\n      'app.columns.location': LocationLinkComponent,\n      'app.columns.tags': TagsColumnComponent,\n      'app.toolbar.toggleEditOffline': ToggleEditOfflineComponent,\n      'app.toolbar.viewNode': ViewNodeComponent,\n      'app.languagePicker': LanguagePickerComponent,\n      'app.logout': LogoutComponent,\n      'app.user': UserInfoComponent,\n      'app.notification-center': NotificationHistoryComponent,\n      'app.user.menu': UserMenuComponent,\n      'app.search.columns.name': SearchResultsRowComponent,\n      'app.search.navbar': SaveSearchSidenavComponent\n    });\n\n    extensions.setEvaluators({\n      canCopyNode: rules.canCopyNode,\n      canToggleJoinLibrary: rules.canToggleJoinLibrary,\n      canEditFolder: rules.canEditFolder,\n      isTrashcanItemSelected: rules.isTrashcanItemSelected,\n      canViewFile: rules.canViewFile,\n      canLeaveLibrary: rules.canLeaveLibrary,\n      canToggleSharedLink: rules.canToggleSharedLink,\n      canShowInfoDrawer: rules.canShowInfoDrawer,\n      canManageFileVersions: rules.canManageFileVersions,\n      canManagePermissions: rules.canManagePermissions,\n      canToggleEditOffline: rules.canToggleEditOffline,\n      canToggleFavorite: rules.canToggleFavorite,\n      isLibraryManager: rules.isLibraryManager,\n      canEditAspects: rules.canEditAspects,\n      canShowExpand: rules.canShowExpand,\n      canInfoPreview: rules.canInfoPreview,\n\n      'app.selection.canDelete': rules.canDeleteSelection,\n      'app.selection.file.canUnlock': rules.canUnlockFile,\n      'app.selection.file.canLock': rules.canLockFile,\n      'app.selection.canDownload': rules.canDownloadSelection,\n      'app.selection.notEmpty': rules.hasSelection,\n      'app.selection.canUnshare': rules.canUnshareNodes,\n      'app.selection.canAddFavorite': rules.canAddFavorite,\n      'app.selection.canRemoveFavorite': rules.canRemoveFavorite,\n      'app.selection.first.canUpdate': rules.canUpdateSelectedNode,\n      'app.selection.file': rules.hasFileSelected,\n      'app.selection.file.canShare': rules.canShareFile,\n      'app.selection.file.isShared': rules.isShared,\n      'app.selection.file.isLocked': rules.hasLockedFiles,\n      'app.selection.file.isLockOwner': rules.isUserWriteLockOwner,\n      'app.selection.file.canUploadVersion': rules.canUploadVersion,\n      'app.selection.library': rules.hasLibrarySelected,\n      'app.selection.isPrivateLibrary': rules.isPrivateLibrary,\n      'app.selection.hasLibraryRole': rules.hasLibraryRole,\n      'app.selection.hasNoLibraryRole': rules.hasNoLibraryRole,\n      'app.selection.folder': rules.hasFolderSelected,\n      'app.selection.folder.canUpdate': rules.canUpdateSelectedFolder,\n      'app.selection.displayedKnowledgeRetrievalButton': rules.canDisplayKnowledgeRetrievalButton,\n\n      'app.navigation.folder.canCreate': rules.canCreateFolder,\n      'app.navigation.folder.canUpload': rules.canUpload,\n      'app.navigation.isTrashcan': rules.isTrashcan,\n      'app.navigation.isNotTrashcan': rules.isNotTrashcan,\n      'app.navigation.isLibraries': rules.isLibraries,\n      'app.navigation.isLibraryFiles': rules.isLibraryFiles,\n      'app.navigation.isPersonalFiles': rules.isPersonalFiles,\n      'app.navigation.isNotLibraries': rules.isNotLibraries,\n      'app.navigation.isSharedFiles': rules.isSharedFiles,\n      'app.navigation.isNotSharedFiles': rules.isNotSharedFiles,\n      'app.navigation.isFavorites': rules.isFavorites,\n      'app.navigation.isNotFavorites': rules.isNotFavorites,\n      'app.navigation.isRecentFiles': rules.isRecentFiles,\n      'app.navigation.isNotRecentFiles': rules.isNotRecentFiles,\n      'app.navigation.isSearchResults': rules.isSearchResults,\n      'app.navigation.isNotSearchResults': rules.isNotSearchResults,\n      'app.navigation.isPreview': rules.isPreview,\n      'app.navigation.isSharedPreview': rules.isSharedPreview,\n      'app.navigation.isFavoritesPreview': rules.isFavoritesPreview,\n      'app.navigation.isSharedFileViewer': rules.isSharedFileViewer,\n\n      'repository.isQuickShareEnabled': rules.hasQuickShareEnabled,\n      'user.isAdmin': rules.isAdmin,\n      'app.canShowLogout': rules.canShowLogout,\n      'app.isContentServiceEnabled': rules.isContentServiceEnabled,\n      'app.isUploadSupported': rules.isUploadSupported,\n      'app.canCreateLibrary': rules.canCreateLibrary,\n      'app.areTagsEnabled': rules.areTagsEnabled,\n      'app.areCategoriesEnabled': rules.areCategoriesEnabled\n    });\n  }\n}\n"]}