@cwa/nuxt-edge 0.0.0-29696494.72f11a4

package/dist/runtime/admin/manager-tabs-resolver.js

@@ -0,0 +1,55 @@
+import { defineAsyncComponent } from "vue";
+import { CwaResourceTypes, getPublishedResourceState } from "#cwa/resources/resource-utils";
+import { useCwa } from "#imports";
+export const DEFAULT_TAB_ORDER = 50;
+export default class ManagerTabsResolver {
+  cwa;
+  constructor() {
+    this.cwa = useCwa();
+  }
+  *getComponentGroupTabs() {
+    yield defineAsyncComponent(() => import("#cwa/templates/components/main/admin/resource-manager/_tabs/group/Group.vue"));
+  }
+  *getComponentPositionTabs(isDynamicPosition) {
+    if (this.cwa.resources.isDataPage.value && isDynamicPosition) {
+      yield defineAsyncComponent(() => import("#cwa/templates/components/main/admin/resource-manager/_tabs/position/DataPage.vue"));
+      return;
+    }
+    if (this.cwa.resources.isDynamicPage.value) {
+      yield defineAsyncComponent(() => import("#cwa/templates/components/main/admin/resource-manager/_tabs/position/DynamicPage.vue"));
+    }
+  }
+  *getComponentTabs(resource) {
+    yield defineAsyncComponent(() => import("#cwa/templates/components/main/admin/resource-manager/_tabs/component/Ui.vue"));
+    yield defineAsyncComponent(() => import("#cwa/templates/components/main/admin/resource-manager/_tabs/component/Order.vue"));
+    if (getPublishedResourceState(resource) !== void 0) {
+      yield defineAsyncComponent(() => import("#cwa/templates/components/main/admin/resource-manager/_tabs/component/Publish.vue"));
+    }
+  }
+  resolve(ops) {
+    let tabs = [
+      defineAsyncComponent(() => import("#cwa/templates/components/main/admin/resource-manager/_tabs/ResourceInfoTab.vue"))
+    ];
+    if (ops.resourceConfig?.managerTabs) {
+      tabs = [...tabs, ...ops.resourceConfig.managerTabs];
+    }
+    if (ops.resourceType) {
+      switch (ops.resourceType) {
+        case CwaResourceTypes.COMPONENT_GROUP:
+          tabs = [...tabs, ...this.getComponentGroupTabs()];
+          break;
+        case CwaResourceTypes.COMPONENT_POSITION: {
+          const positionTabs = this.getComponentPositionTabs(ops.resource.data?._metadata.isDynamicPosition);
+          if (positionTabs) {
+            tabs = [...tabs, ...positionTabs];
+          }
+          break;
+        }
+        default:
+          tabs = [...tabs, ...this.getComponentTabs(ops.resource)];
+          break;
+      }
+    }
+    return tabs;
+  }
+}

package/dist/runtime/admin/navigation-guard.d.ts

@@ -0,0 +1,18 @@
+import type { RouteLocationNormalized, Router } from 'vue-router';
+import type { AdminStore } from '../storage/stores/admin/admin-store.js';
+export default class NavigationGuard {
+    private router;
+    private programmatic;
+    private readonly _adminStore;
+    constructor(router: Router, adminStoreDefinition: AdminStore);
+    private extendRouteMethods;
+    private isRouteForcedNavigation;
+    private allowNavigation;
+    get navigationDisabled(): boolean;
+    get adminNavigationGuardFn(): (toRoute: RouteLocationNormalized) => boolean | {
+        path: string;
+        query: import("vue-router").LocationQuery;
+        hash: string;
+    };
+    private get adminStore();
+}

package/dist/runtime/admin/navigation-guard.js

@@ -0,0 +1,57 @@
+export default class NavigationGuard {
+  constructor(router, adminStoreDefinition) {
+    this.router = router;
+    this.extendRouteMethods();
+    this._adminStore = adminStoreDefinition.useStore();
+  }
+  router;
+  programmatic = false;
+  _adminStore;
+  extendRouteMethods() {
+    ["push", "go", "back", "forward", "replace"].forEach((methodName) => {
+      const routerFn = this.router[methodName];
+      this.router[methodName] = (...args) => {
+        this.programmatic = true;
+        return routerFn.apply(this.router, args);
+      };
+    });
+  }
+  isRouteForcedNavigation(toRoute) {
+    const cwaForceQuery = toRoute.query?.cwa_force === "true";
+    if (cwaForceQuery) {
+      delete toRoute.query.cwa_force;
+      return true;
+    }
+    const cwaForceParam = toRoute.params?.cwa_force;
+    return cwaForceParam === "true";
+  }
+  allowNavigation(toRoute) {
+    return this.isRouteForcedNavigation(toRoute) || !this.programmatic || !this.navigationDisabled;
+  }
+  get navigationDisabled() {
+    return this.adminStore.state.isEditing && !this.adminStore.state.navigationGuardDisabled;
+  }
+  get adminNavigationGuardFn() {
+    return (toRoute) => {
+      try {
+        const cwaForceQuery = toRoute.query?.cwa_force;
+        if (!this.allowNavigation(toRoute)) {
+          return false;
+        }
+        if (!cwaForceQuery) {
+          return true;
+        }
+        return {
+          path: toRoute.path,
+          query: toRoute.query,
+          hash: toRoute.hash
+        };
+      } finally {
+        this.programmatic = false;
+      }
+    };
+  }
+  get adminStore() {
+    return this._adminStore;
+  }
+}

package/dist/runtime/admin/resource-stack-manager.d.ts

@@ -0,0 +1,93 @@
+import { CwaResourceTypes } from '#cwa/resources/resource-utils';
+import type { Resources } from '#cwa/resources/resources';
+import type { ComponentUi, ManagerTab } from '#cwa/types';
+import type { ComputedRef, Ref } from 'vue';
+import type { AdminStore } from '../storage/stores/admin/admin-store.js';
+import type { ResourcesStore } from '../storage/stores/resources/resources-store.js';
+import type { ManageableResourceOps, StyleOptions } from './manageable-resource.js';
+interface _ResourceStackItem {
+    iri: string;
+    domElements: Ref<HTMLElement[]>;
+    displayName?: string;
+    managerTabs?: ManagerTab[];
+    ui?: ComponentUi[];
+    childIris: Ref<string[]>;
+    styles?: ComputedRef<StyleOptions | undefined>;
+    resourceOps?: ManageableResourceOps;
+}
+export type ResourceStackItem = _ResourceStackItem;
+interface AddToStackWindowEvent {
+    clickTarget: EventTarget | null;
+}
+interface AddToStackEvent extends _ResourceStackItem, AddToStackWindowEvent {
+}
+export interface AddResourceEvent {
+    addAfter: boolean | null;
+    targetIri: string;
+    closest: {
+        position?: string;
+        group?: string;
+    };
+    pageDataProperty?: string;
+}
+export default class ResourceStackManager {
+    private adminStoreDefinition;
+    private readonly resourcesStoreDefinition;
+    private readonly resources;
+    readonly forcePublishedVersion: Ref<boolean | undefined>;
+    readonly showManager: Ref<boolean>;
+    private readonly isLayoutStack;
+    private readonly _isEditingLayout;
+    private readonly currentClickTarget;
+    private readonly currentResourceStack;
+    private readonly previousResourceStack;
+    private readonly lastContextTarget;
+    private readonly contextResourceStack;
+    private readonly cachedCurrentStackItem;
+    private readonly resourceManagerState;
+    private readonly yOffset;
+    private focusComponent;
+    private focusWrapper;
+    private focusProxy;
+    private _currentStackItem;
+    private _currentIri;
+    private readonly _adminStore;
+    private readonly _resourcesStore;
+    constructor(adminStoreDefinition: AdminStore, resourcesStoreDefinition: ResourcesStore, resources: Resources);
+    private handleCurrentStackItemChange;
+    get isEditingLayout(): Ref<boolean, boolean>;
+    getState(prop: string): any;
+    setState(prop: string, value: any): void;
+    get contextStack(): ComputedRef<_ResourceStackItem[]>;
+    get resourceStack(): ComputedRef<_ResourceStackItem[]>;
+    get isPopulating(): ComputedRef<boolean>;
+    get isContextPopulating(): ComputedRef<boolean>;
+    get currentStackItem(): ComputedRef<_ResourceStackItem | undefined>;
+    get currentIri(): ComputedRef<string | undefined>;
+    resetStack(clearContextStack?: boolean): void;
+    getClosestStackItemByType(type: CwaResourceTypes): string | undefined;
+    private confirmStackChange;
+    selectStackIndex(index: number, fromContext: boolean): Promise<void>;
+    private getCurrentTarget;
+    completeStack(event: AddToStackWindowEvent, isContext?: boolean, type?: undefined | 'page' | 'layout'): void;
+    addToStack(event: AddToStackEvent, isContext?: boolean, resourceOps?: ManageableResourceOps): void;
+    private _addToStack;
+    private finishStack;
+    isComponentGroupDisabled(iri: string, location?: string): boolean;
+    private filterDisabledStackItems;
+    private getCurrentStack;
+    private insertResourceStackItem;
+    redrawFocus(): void;
+    private createFocusComponent;
+    private removeFocusComponent;
+    private scrollIntoView;
+    private isElementOutsideViewport;
+    private listenEditModeChange;
+    private listenCurrentIri;
+    private resetResourceManagerVars;
+    private isResourceInStack;
+    private get isEditing();
+    private get adminStore();
+    private get resourcesStore();
+}
+export {};

package/dist/runtime/admin/resource-stack-manager.js

@@ -0,0 +1,388 @@
+import { CwaResourceTypes, getResourceTypeFromIri } from "#cwa/resources/resource-utils";
+import ConfirmDialog from "#cwa/templates/components/core/ConfirmDialog.vue";
+import { useNuxtApp } from "#imports";
+import { consola as logger } from "consola";
+import { computed, createApp, nextTick, ref, shallowRef, watch } from "vue";
+import { createConfirmDialog } from "vuejs-confirm-dialog";
+import ComponentFocus from "../templates/components/main/admin/resource-manager/ComponentFocus.vue";
+export default class ResourceStackManager {
+  constructor(adminStoreDefinition, resourcesStoreDefinition, resources) {
+    this.adminStoreDefinition = adminStoreDefinition;
+    this.resourcesStoreDefinition = resourcesStoreDefinition;
+    this.resources = resources;
+    this._adminStore = this.adminStoreDefinition.useStore();
+    this._resourcesStore = this.resourcesStoreDefinition.useStore();
+    watch(() => this.isEditing, this.listenEditModeChange.bind(this));
+    watch(this.currentIri, this.listenCurrentIri.bind(this));
+    watch(this.currentStackItem, this.handleCurrentStackItemChange.bind(this));
+    watch(this.showManager, (newValue) => !newValue && this.removeFocusComponent());
+  }
+  adminStoreDefinition;
+  resourcesStoreDefinition;
+  resources;
+  forcePublishedVersion = ref();
+  showManager = ref(false);
+  isLayoutStack = ref(false);
+  _isEditingLayout = ref(false);
+  currentClickTarget = ref(null);
+  currentResourceStack = shallowRef([]);
+  previousResourceStack = shallowRef([]);
+  lastContextTarget = ref(null);
+  contextResourceStack = shallowRef([]);
+  cachedCurrentStackItem = shallowRef();
+  resourceManagerState = ref({});
+  yOffset = 100;
+  focusComponent;
+  focusWrapper;
+  focusProxy;
+  _currentStackItem;
+  _currentIri;
+  _adminStore;
+  _resourcesStore;
+  async handleCurrentStackItemChange(currentStackItem) {
+    this.cachedCurrentStackItem.value = currentStackItem;
+    await nextTick();
+    this.scrollIntoView();
+    this.createFocusComponent();
+  }
+  get isEditingLayout() {
+    return this._isEditingLayout;
+  }
+  getState(prop) {
+    return this.resourceManagerState.value[prop];
+  }
+  setState(prop, value) {
+    Object.assign(this.resourceManagerState.value, { [prop]: value });
+  }
+  get contextStack() {
+    return computed(() => {
+      return this.lastContextTarget.value ? [] : this.contextResourceStack.value;
+    });
+  }
+  get resourceStack() {
+    return computed(() => {
+      return this.currentClickTarget.value ? [] : this.currentResourceStack.value;
+    });
+  }
+  get isPopulating() {
+    return computed(() => !!this.currentClickTarget.value);
+  }
+  get isContextPopulating() {
+    return computed(() => !!this.lastContextTarget.value);
+  }
+  get currentStackItem() {
+    if (!this._currentStackItem) {
+      this._currentStackItem = computed(() => {
+        if (!this.showManager.value) {
+          return;
+        }
+        if (this.currentClickTarget.value) {
+          return this.cachedCurrentStackItem.value;
+        }
+        return this.currentResourceStack.value[0];
+      });
+    }
+    return this._currentStackItem;
+  }
+  get currentIri() {
+    if (!this._currentIri) {
+      this._currentIri = computed(() => {
+        const currentStackItem = this.currentStackItem.value;
+        if (!currentStackItem) {
+          return;
+        }
+        const stackIri = currentStackItem.iri;
+        if (this.forcePublishedVersion.value === void 0) {
+          return stackIri;
+        }
+        if (this.forcePublishedVersion.value) {
+          return this.resourcesStore.findPublishedComponentIri(stackIri);
+        }
+        return this.resourcesStore.findDraftComponentIri(stackIri);
+      });
+    }
+    return this._currentIri;
+  }
+  resetStack(clearContextStack) {
+    if (clearContextStack) {
+      this.lastContextTarget.value = null;
+      this.contextResourceStack.value = [];
+      return;
+    }
+    this.previousResourceStack.value = this.currentResourceStack.value;
+    this.currentClickTarget.value = null;
+    this.currentResourceStack.value = [];
+  }
+  getClosestStackItemByType(type) {
+    const currentStack = this.resourceStack.value;
+    for (const stackItem of currentStack) {
+      const stackItemIri = stackItem.iri;
+      const resourceType = getResourceTypeFromIri(stackItemIri);
+      if (resourceType === type) {
+        return stackItemIri;
+      }
+    }
+  }
+  async confirmStackChange(alertData, fromContext) {
+    let cachedNewStack;
+    if (!fromContext) {
+      cachedNewStack = this.currentResourceStack.value;
+      this.currentResourceStack.value = this.previousResourceStack.value;
+    }
+    const dialog = createConfirmDialog(ConfirmDialog);
+    const { isCanceled } = await dialog.reveal(alertData);
+    if (isCanceled) {
+      if (fromContext) {
+        this.resetStack(true);
+      }
+      return false;
+    }
+    if (cachedNewStack) {
+      this.currentResourceStack.value = cachedNewStack;
+    }
+    return true;
+  }
+  async selectStackIndex(index, fromContext) {
+    if (!this.isEditing) {
+      return;
+    }
+    const fromStack = fromContext ? this.contextResourceStack : this.currentResourceStack;
+    const currentLength = fromStack.value.length;
+    if (!currentLength) {
+      this.isLayoutStack.value = this._isEditingLayout.value;
+      this.showManager.value = false;
+      return;
+    }
+    if (index < 0 || index > currentLength - 1) {
+      logger.error(`Cannot select stack index: '${index}' is out of range`);
+      return;
+    }
+    if (this._isEditingLayout.value !== this.isLayoutStack.value) {
+      const confirmed = await this.confirmStackChange({ title: "Are you sure?", content: `<p>Are you sure you want to switch and edit the ${this.isLayoutStack.value ? "layout" : "page"}?</p>` }, fromContext);
+      if (!confirmed) {
+        this.isLayoutStack.value = this._isEditingLayout.value;
+        return;
+      }
+      this._isEditingLayout.value = this.isLayoutStack.value;
+    }
+    this.currentResourceStack.value = fromStack.value.slice(index);
+    this.showManager.value = true;
+    if (fromContext) {
+      this.resetStack(true);
+    }
+  }
+  getCurrentTarget(isContext) {
+    return isContext ? this.lastContextTarget : this.currentClickTarget;
+  }
+  completeStack(event, isContext, type) {
+    if (type) {
+      this.isLayoutStack.value = type === "layout";
+    }
+    this._addToStack(event, isContext);
+  }
+  addToStack(event, isContext, resourceOps) {
+    return this._addToStack(event, isContext, resourceOps);
+  }
+  _addToStack(event, isContext, resourceOps) {
+    const currentTarget = this.getCurrentTarget(!!isContext);
+    const { clickTarget, ...resourceStackItem } = event;
+    const isResourceClick = "iri" in resourceStackItem;
+    if (!currentTarget.value) {
+      this.resetStack(isContext);
+      if (!isContext) {
+        this.resetStack(true);
+      }
+    }
+    if (!this.isEditing) {
+      return;
+    }
+    if (isResourceClick && this.isResourceInStack(resourceStackItem.iri, !!isContext) && currentTarget.value) {
+      return;
+    }
+    if (!isResourceClick) {
+      this.finishStack(!!isContext);
+      return;
+    }
+    resourceStackItem.resourceOps = resourceOps;
+    this.insertResourceStackItem(resourceStackItem, !!isContext);
+    currentTarget.value = clickTarget;
+  }
+  finishStack(isContext) {
+    this.filterDisabledStackItems(isContext);
+    this.getCurrentTarget(isContext).value = null;
+    if (this.currentResourceStack.value.length === 0) {
+      this.previousResourceStack.value = [];
+    }
+  }
+  isComponentGroupDisabled(iri, location) {
+    if (getResourceTypeFromIri(iri) !== CwaResourceTypes.COMPONENT_GROUP) {
+      return false;
+    }
+    if (this.resources.isDataPage.value) {
+      if (this.isLayoutStack.value) {
+        return false;
+      }
+      if (!location) {
+        return true;
+      }
+      const locationType = getResourceTypeFromIri(location);
+      if (locationType === CwaResourceTypes.LAYOUT) {
+        return false;
+      }
+      return locationType !== void 0 && [CwaResourceTypes.PAGE, CwaResourceTypes.PAGE_DATA].includes(locationType);
+    }
+    return false;
+  }
+  filterDisabledStackItems(isContext) {
+    const stackRef = this.getCurrentStack(isContext);
+    const stack = stackRef.value;
+    const stackEntries = stack.entries();
+    const newStack = [];
+    const groupDisabledCache = {};
+    const findNextComponentGroup = (startIndex) => {
+      for (let i = startIndex; i < stack.length; i++) {
+        const item = stack[i];
+        if (getResourceTypeFromIri(item.iri) === CwaResourceTypes.COMPONENT_GROUP) {
+          if (groupDisabledCache[item.iri]) {
+            return groupDisabledCache[item.iri];
+          }
+          const location = stack[i + 1]?.iri;
+          groupDisabledCache[item.iri] = {
+            iri: item.iri,
+            location,
+            isDisabled: this.isComponentGroupDisabled(item.iri, location)
+          };
+          return groupDisabledCache[item.iri];
+        }
+      }
+    };
+    for (const [index, item] of stackEntries) {
+      const resourceType = getResourceTypeFromIri(item.iri);
+      if (resourceType && [CwaResourceTypes.COMPONENT_GROUP, CwaResourceTypes.COMPONENT].includes(resourceType)) {
+        const nextGroup = findNextComponentGroup(index);
+        if (!this.resources.isPageDataResource(item.iri).value && nextGroup?.isDisabled) {
+          continue;
+        }
+      }
+      newStack.push(item);
+    }
+    stackRef.value = newStack;
+  }
+  getCurrentStack(isContext) {
+    return isContext ? this.contextResourceStack : this.currentResourceStack;
+  }
+  insertResourceStackItem(resourceStackItem, isContext) {
+    const stack = this.getCurrentStack(!!isContext);
+    const iris = this.resourcesStore.findAllPublishableIris(resourceStackItem.iri);
+    const insertAtIndex = stack.value.findIndex((existingStackItem) => {
+      const existingItemChildren = existingStackItem.childIris.value;
+      if (!existingItemChildren) {
+        return false;
+      }
+      return existingItemChildren.some((r) => iris.includes(r));
+    });
+    insertAtIndex === -1 ? stack.value.push(resourceStackItem) : stack.value.splice(insertAtIndex, 0, resourceStackItem);
+  }
+  redrawFocus() {
+    if (!this.focusProxy) {
+      return;
+    }
+    this.focusProxy.redraw();
+  }
+  createFocusComponent() {
+    this.removeFocusComponent();
+    const stackItem = this.currentStackItem.value;
+    if (!this.currentIri.value || !stackItem) {
+      return;
+    }
+    this.focusComponent = createApp(ComponentFocus, {
+      iri: this.currentIri,
+      domElements: stackItem.domElements
+    });
+    this.focusWrapper = document.createElement("div");
+    this.focusWrapper.className = "cwa:absolute cwa:z-manager-focus cwa:top-0 cwa:left-0 cwa:focus-wrapper";
+    useNuxtApp().vueApp._container?.appendChild(this.focusWrapper);
+    this.focusProxy = this.focusComponent.mount(this.focusWrapper);
+  }
+  removeFocusComponent() {
+    if (this.focusComponent) {
+      const toUnmount = this.focusComponent;
+      this.focusComponent = void 0;
+      this.focusProxy = void 0;
+      toUnmount.unmount();
+    }
+    if (this.focusWrapper) {
+      const toRemove = this.focusWrapper;
+      this.focusWrapper = void 0;
+      toRemove.remove();
+    }
+  }
+  scrollIntoView() {
+    let element;
+    let elementOutOfView = false;
+    const stackItem = this.currentStackItem.value;
+    if (!stackItem) {
+      return;
+    }
+    for (const elCandidate of stackItem.domElements.value) {
+      if (elCandidate.nodeType === Node.ELEMENT_NODE) {
+        if (!element) {
+          element = elCandidate;
+        }
+        if (this.isElementOutsideViewport(element)) {
+          elementOutOfView = true;
+        }
+        if (elementOutOfView && element) {
+          break;
+        }
+      }
+    }
+    if (!element || !elementOutOfView) {
+      return;
+    }
+    const y = element.getBoundingClientRect().top + window.scrollY - this.yOffset;
+    window.scrollTo({ top: y, behavior: "smooth" });
+  }
+  isElementOutsideViewport(el) {
+    const { top, left, bottom, right } = el.getBoundingClientRect();
+    const { innerHeight, innerWidth } = window;
+    let visibleHeight = innerHeight;
+    const managerSpacer = document.getElementById("cwa-manager-spacer");
+    if (managerSpacer) {
+      visibleHeight -= managerSpacer.offsetHeight;
+    }
+    return top < this.yOffset || left < 0 || bottom > visibleHeight || right > innerWidth;
+  }
+  listenEditModeChange(isEditing) {
+    if (!isEditing) {
+      this.showManager.value = false;
+      this.resetStack(true);
+      this._isEditingLayout.value = false;
+    }
+  }
+  listenCurrentIri(newIri, oldIri) {
+    if (newIri && oldIri) {
+      if (this.resourcesStore.isIriPublishableEquivalent(oldIri, newIri)) {
+        return;
+      }
+    }
+    this.resetResourceManagerVars();
+  }
+  resetResourceManagerVars() {
+    this.forcePublishedVersion.value = void 0;
+    this.resourceManagerState.value = {};
+  }
+  isResourceInStack(iri, isContext) {
+    const stack = isContext ? this.contextResourceStack : this.currentResourceStack;
+    return !!stack.value.find((el) => el.iri === iri);
+  }
+  get isEditing() {
+    return this.adminStore.state.isEditing;
+  }
+  get adminStore() {
+    return this._adminStore;
+  }
+  get resourcesStore() {
+    return this._resourcesStore;
+  }
+}

package/dist/runtime/api/api-documentation.d.ts

@@ -0,0 +1,28 @@
+import type { ApiDocumentationStore } from '../storage/stores/api-documentation/api-documentation-store.js';
+import type { CwaApiDocumentationDataInterface } from '../storage/stores/api-documentation/state.js';
+import type CwaFetch from './fetcher/cwa-fetch.js';
+export interface ApiDocumentationComponentMetadata {
+    resourceName: string;
+    endpoint: string;
+    isPublishable: boolean;
+}
+export interface ApiDocumentationComponentMetadataCollection {
+    [key: string]: ApiDocumentationComponentMetadata;
+}
+export default class ApiDocumentation {
+    private readonly cwaFetch;
+    private readonly _store;
+    private readonly apiDocsSet;
+    private apiDocPromise;
+    constructor(cwaFetch: CwaFetch, store: ApiDocumentationStore);
+    setDocsPathFromLinkHeader(linkHeader: string): void;
+    getApiDocumentation(refresh?: boolean): Promise<CwaApiDocumentationDataInterface | undefined>;
+    getComponentMetadata(refresh?: boolean, includePosition?: boolean): Promise<undefined | ApiDocumentationComponentMetadataCollection>;
+    private reRunGetApiDocumentationWhenReady;
+    private getCurrentApiDocs;
+    private awaitApiDocPromise;
+    private fetchAllApiDocumentation;
+    private doRequest;
+    private get store();
+    private get docsPath();
+}