@cwa/nuxt-edge 0.0.0-29696494.72f11a4

package/dist/runtime/server/useFetcher.js

@@ -0,0 +1,40 @@
+import { $fetch } from "ofetch";
+import { consola } from "consola";
+import { useRuntimeConfig } from "#imports";
+import { options } from "#cwa/server-options.ts";
+import useCwaSiteConfig from "#cwa/composables/useCwaSiteConfig";
+export const useFetcher = () => {
+  const { public: { cwa: { apiUrl, apiUrlBrowser } } } = useRuntimeConfig();
+  const resolvedUrl = apiUrl || apiUrlBrowser || "";
+  const fetcher = $fetch.create({
+    baseURL: resolvedUrl,
+    headers: {
+      accept: "application/ld+json,application/json"
+    },
+    credentials: "include"
+  });
+  return {
+    fetcher,
+    options
+  };
+};
+export const resolveConfigEventHandler = async (e) => {
+  if (e?.context.cwaSiteConfig) {
+    return e.context.cwaSiteConfig;
+  }
+  const { mergeConfig, responseToConfig } = useCwaSiteConfig();
+  const { fetcher, options: options2 } = useFetcher();
+  try {
+    const data = await fetcher("/_/site_config_parameters", {
+      credentials: "omit"
+    });
+    const config = mergeConfig(options2.siteConfig, responseToConfig(data, true));
+    if (e)
+      e.context.cwaSiteConfig = config;
+    return config;
+  } catch (e2) {
+    consola.error(e2);
+    return;
+  }
+};
+export default useFetcher;

package/dist/runtime/storage/storage.d.ts

@@ -0,0 +1,25 @@
+import { ResourcesStore } from './stores/resources/resources-store.js';
+import { FetcherStore } from './stores/fetcher/fetcher-store.js';
+import { MercureStore } from './stores/mercure/mercure-store.js';
+import { ApiDocumentationStore } from './stores/api-documentation/api-documentation-store.js';
+import { AuthStore } from './stores/auth/auth-store.js';
+import { AdminStore } from './stores/admin/admin-store.js';
+import { ErrorStore } from './stores/error/error-store.js';
+import { SiteConfigStore } from '#cwa/storage/stores/site-config/site-config-store';
+export interface CwaStores {
+    resources: ResourcesStore;
+    fetcher: FetcherStore;
+    mercure: MercureStore;
+    apiDocumentation: ApiDocumentationStore;
+    auth: AuthStore;
+    admin: AdminStore;
+    error: ErrorStore;
+    siteConfig: SiteConfigStore;
+}
+export declare class Storage {
+    readonly stores: CwaStores;
+    private readonly uniquePromiseStore;
+    constructor(storeName: string);
+    private getUniquePromiseStore;
+    addUniquePromise(scope: string, key: string, fn: () => Promise<void>): Promise<void> | undefined;
+}

package/dist/runtime/storage/storage.js

@@ -0,0 +1,48 @@
+import { reactive } from "vue";
+import {
+  ResourcesStore
+} from "./stores/resources/resources-store.js";
+import { FetcherStore } from "./stores/fetcher/fetcher-store.js";
+import { MercureStore } from "./stores/mercure/mercure-store.js";
+import {
+  ApiDocumentationStore
+} from "./stores/api-documentation/api-documentation-store.js";
+import { AuthStore } from "./stores/auth/auth-store.js";
+import { AdminStore } from "./stores/admin/admin-store.js";
+import { ErrorStore } from "./stores/error/error-store.js";
+import { SiteConfigStore } from "#cwa/storage/stores/site-config/site-config-store";
+export class Storage {
+  stores;
+  uniquePromiseStore;
+  constructor(storeName) {
+    this.stores = {
+      resources: new ResourcesStore(storeName),
+      fetcher: new FetcherStore(storeName),
+      mercure: new MercureStore(storeName),
+      apiDocumentation: new ApiDocumentationStore(storeName),
+      auth: new AuthStore(storeName),
+      admin: new AdminStore(storeName),
+      error: new ErrorStore(storeName),
+      siteConfig: new SiteConfigStore(storeName)
+    };
+    this.uniquePromiseStore = {};
+  }
+  getUniquePromiseStore(scope) {
+    const existingMap = this.uniquePromiseStore[scope];
+    if (existingMap) {
+      return existingMap;
+    }
+    this.uniquePromiseStore[scope] = reactive(/* @__PURE__ */ new Map());
+    return this.uniquePromiseStore[scope];
+  }
+  addUniquePromise(scope, key, fn) {
+    const map = this.getUniquePromiseStore(scope);
+    if (map.has(key)) {
+      return map.get(key);
+    }
+    const requestPromise = fn().finally(() => {
+      map.delete(key);
+    });
+    map.set(key, requestPromise);
+  }
+}

package/dist/runtime/storage/stores/admin/actions.d.ts

@@ -0,0 +1,5 @@
+import type { CwaAdminStateInterface } from './state.js';
+export interface CwaAdminActionsInterface {
+    toggleEdit(isEditing?: boolean): void;
+}
+export default function (adminState: CwaAdminStateInterface): CwaAdminActionsInterface;

package/dist/runtime/storage/stores/admin/actions.js

@@ -0,0 +1,10 @@
+export default function(adminState) {
+  return {
+    toggleEdit(isEditing) {
+      adminState.state.isEditing = isEditing !== void 0 ? isEditing : !adminState.state.isEditing;
+      if (!adminState.state.isEditing) {
+        adminState.state.navigationGuardDisabled = false;
+      }
+    }
+  };
+}

package/dist/runtime/storage/stores/admin/admin-store.d.ts

@@ -0,0 +1,18 @@
+import type { CwaPiniaStoreDefinitionInterface, CwaPiniaStoreInterface, CwaStore } from '../cwa-store-types.js';
+import type { CwaAdminStateInterface } from './state.js';
+import type { CwaAdminActionsInterface } from './actions.js';
+/**
+ * Interface Definitions
+ */
+export interface CwaAdminInterface extends CwaAdminStateInterface, CwaAdminActionsInterface {
+}
+export type CwaAdminStoreDefinitionInterface = CwaPiniaStoreDefinitionInterface<`${string}.admin`, CwaAdminInterface>;
+export type CwaAdminStoreInterface = CwaPiniaStoreInterface<`${string}.admin`, CwaAdminInterface>;
+/**
+ * Main Store Class
+ */
+export declare class AdminStore implements CwaStore {
+    private readonly storeDefinition;
+    constructor(storeName: string);
+    useStore(): CwaAdminStoreInterface;
+}

package/dist/runtime/storage/stores/admin/admin-store.js

@@ -0,0 +1,20 @@
+import {
+  defineStore
+} from "pinia";
+import CwaAdminState from "./state.js";
+import CwaAdminActions from "./actions.js";
+export class AdminStore {
+  storeDefinition;
+  constructor(storeName) {
+    this.storeDefinition = defineStore(`${storeName}.admin`, () => {
+      const adminState = CwaAdminState();
+      return {
+        ...adminState,
+        ...CwaAdminActions(adminState)
+      };
+    });
+  }
+  useStore() {
+    return this.storeDefinition();
+  }
+}

package/dist/runtime/storage/stores/admin/state.d.ts

@@ -0,0 +1,7 @@
+export interface CwaAdminStateInterface {
+    state: {
+        isEditing: boolean;
+        navigationGuardDisabled: boolean;
+    };
+}
+export default function (): CwaAdminStateInterface;

package/dist/runtime/storage/stores/admin/state.js

@@ -0,0 +1,9 @@
+import { reactive } from "vue";
+export default function() {
+  return {
+    state: reactive({
+      isEditing: false,
+      navigationGuardDisabled: false
+    })
+  };
+}

package/dist/runtime/storage/stores/api-documentation/api-documentation-store.d.ts

@@ -0,0 +1,16 @@
+import type { CwaPiniaStoreDefinitionInterface, CwaPiniaStoreInterface, CwaStore } from '../cwa-store-types.js';
+import type { CwaApiDocumentationStateInterface } from './state.js';
+/**
+ * Interface Definitions
+ */
+export type CwaApiDocumentationInterface = CwaApiDocumentationStateInterface;
+export type CwaApiDocumentationStoreDefinitionInterface = CwaPiniaStoreDefinitionInterface<`${string}.apiDocumentation`, CwaApiDocumentationInterface>;
+export type CwaApiDocumentationStoreInterface = CwaPiniaStoreInterface<`${string}.apiDocumentation`, CwaApiDocumentationInterface>;
+/**
+ * Main Store Class
+ */
+export declare class ApiDocumentationStore implements CwaStore {
+    private readonly storeDefinition;
+    constructor(storeName: string);
+    useStore(): CwaApiDocumentationStoreInterface;
+}

package/dist/runtime/storage/stores/api-documentation/api-documentation-store.js

@@ -0,0 +1,18 @@
+import {
+  defineStore
+} from "pinia";
+import CwaApiDocumentationState from "./state.js";
+export class ApiDocumentationStore {
+  storeDefinition;
+  constructor(storeName) {
+    this.storeDefinition = defineStore(`${storeName}.apiDocumentation`, () => {
+      const apiDocumentationState = CwaApiDocumentationState();
+      return {
+        ...apiDocumentationState
+      };
+    });
+  }
+  useStore() {
+    return this.storeDefinition();
+  }
+}

package/dist/runtime/storage/stores/api-documentation/state.d.ts

@@ -0,0 +1,71 @@
+import type { Ref } from 'vue';
+import type { CwaResource } from '#cwa/resources/resource-utils';
+export interface PageDataMetadataResource extends CwaResource {
+    '@type': 'PageDataMetadata';
+    'resourceClass': string;
+    'properties': {
+        'property': string;
+        'componentShortName': string;
+        '@id': string;
+        '@type': 'PageDataPropertyMetadata';
+    }[];
+}
+export interface CwaApiDocumentationDataInterface {
+    entrypoint?: {
+        '@context': string;
+        '@id': string;
+        '@type': 'Entrypoint';
+        [key: string]: string;
+    };
+    docs?: {
+        '@context': any;
+        '@id': string;
+        '@type': 'ApiDocumentation';
+        'title': string;
+        'description': string;
+        'entrypoint': string;
+        'supportedClass': Array<{
+            '@id': string;
+            '@type': string;
+            'title': string;
+            'description': string;
+            'supportedOperation': Array<{
+                '@type': Array<string> | string;
+                'method': string;
+                'title': string;
+                'returns': string;
+            }>;
+            'supportedProperty': Array<{
+                '@type': 'SupportedProperty';
+                'title': string;
+                'required': boolean;
+                'readable': boolean;
+                'writeable': boolean;
+                'property': Array<{
+                    '@id': string;
+                    '@type': string;
+                    'domain': string;
+                    'range': string;
+                }>;
+            }>;
+        }>;
+        'info': {
+            version: string;
+        };
+    };
+    pageDataMetadata?: {
+        '@context': {
+            '@vocab': string;
+            'hydra': string;
+            'properties': 'PageDataMetadata/properties';
+        };
+        '@id': '/_/page_data_metadatas';
+        '@type': 'Collection';
+        'member': PageDataMetadataResource[];
+    };
+}
+export interface CwaApiDocumentationStateInterface {
+    docsPath: Ref<string | null>;
+    apiDocumentation?: CwaApiDocumentationDataInterface;
+}
+export default function (): CwaApiDocumentationStateInterface;

package/dist/runtime/storage/stores/api-documentation/state.js

@@ -0,0 +1,6 @@
+import { ref } from "vue";
+export default function() {
+  return {
+    docsPath: ref(null)
+  };
+}

package/dist/runtime/storage/stores/auth/auth-store.d.ts

@@ -0,0 +1,16 @@
+import type { CwaPiniaStoreDefinitionInterface, CwaPiniaStoreInterface, CwaStore } from '../cwa-store-types.js';
+import type { CwaAuthStateInterface } from './state.js';
+/**
+ * Interface Definitions
+ */
+export type CwaAuthInterface = CwaAuthStateInterface;
+export type CwaAuthStoreDefinitionInterface = CwaPiniaStoreDefinitionInterface<`${string}.auth`, CwaAuthInterface>;
+export type CwaAuthStoreInterface = CwaPiniaStoreInterface<`${string}.auth`, CwaAuthInterface>;
+/**
+ * Main Store Class
+ */
+export declare class AuthStore implements CwaStore {
+    private readonly storeDefinition;
+    constructor(storeName: string);
+    useStore(): CwaAuthStoreInterface;
+}

package/dist/runtime/storage/stores/auth/auth-store.js

@@ -0,0 +1,18 @@
+import {
+  defineStore
+} from "pinia";
+import CwaAuthState from "./state.js";
+export class AuthStore {
+  storeDefinition;
+  constructor(storeName) {
+    this.storeDefinition = defineStore(`${storeName}.auth`, () => {
+      const fetcherState = CwaAuthState();
+      return {
+        ...fetcherState
+      };
+    });
+  }
+  useStore() {
+    return this.storeDefinition();
+  }
+}

package/dist/runtime/storage/stores/auth/state.d.ts

@@ -0,0 +1,19 @@
+import type { CwaResource } from '../../../resources/resource-utils.js';
+export declare enum CwaUserRoles {
+    SUPER_ADMIN = "ROLE_SUPER_ADMIN",
+    ADMIN = "ROLE_ADMIN",
+    ALLOWED_TO_SWITCH = "ROLE_ALLOWED_TO_SWITCH",
+    USER = "ROLE_USER"
+}
+export interface CwaUser extends CwaResource {
+    emailAddress: string;
+    enabled: boolean;
+    roles: (string | CwaUserRoles)[];
+    username: string;
+}
+export interface CwaAuthStateInterface {
+    data: {
+        user?: CwaUser;
+    };
+}
+export default function (): CwaAuthStateInterface;

package/dist/runtime/storage/stores/auth/state.js

@@ -0,0 +1,15 @@
+import { reactive } from "vue";
+export var CwaUserRoles = /* @__PURE__ */ ((CwaUserRoles2) => {
+  CwaUserRoles2["SUPER_ADMIN"] = "ROLE_SUPER_ADMIN";
+  CwaUserRoles2["ADMIN"] = "ROLE_ADMIN";
+  CwaUserRoles2["ALLOWED_TO_SWITCH"] = "ROLE_ALLOWED_TO_SWITCH";
+  CwaUserRoles2["USER"] = "ROLE_USER";
+  return CwaUserRoles2;
+})(CwaUserRoles || {});
+export default function() {
+  return {
+    data: reactive({
+      user: void 0
+    })
+  };
+}

package/dist/runtime/storage/stores/cwa-store-types.d.ts

@@ -0,0 +1,14 @@
+import type {
+  SetupStoreDefinition,
+  Store,
+  StoreActions,
+  StoreGetters,
+  StoreState,
+} from 'pinia'
+
+export interface CwaStore {
+  useStore(): any
+}
+
+export declare type CwaPiniaStoreDefinitionInterface<N extends string, I> = SetupStoreDefinition<N, I>
+export declare type CwaPiniaStoreInterface<N extends string, I> = Store<N, StoreState<I>, StoreGetters<I>, StoreActions<I>>

package/dist/runtime/storage/stores/error/actions.d.ts

@@ -0,0 +1,11 @@
+import type { FetchError } from 'ofetch';
+import type { ApiResourceEvent } from '../../../resources/resources-manager.js';
+import type { CwaErrorEvent, CwaErrorStateInterface } from './state.js';
+export interface CwaErrorActionsInterface {
+    error(event: ApiResourceEvent, error: FetchError): void;
+    manual(error: CwaErrorEvent): void;
+    clear(): void;
+    removeById(id: number): void;
+    removeByEndpoint(endpoint: string): void;
+}
+export default function (errorState: CwaErrorStateInterface): CwaErrorActionsInterface;

package/dist/runtime/storage/stores/error/actions.js

@@ -0,0 +1,73 @@
+import { ErrorType } from "./state.js";
+function getErrorType(type) {
+  const typeKey = type?.includes("/") ? type.split("/").pop() ?? type : type;
+  switch (typeKey) {
+    case "Error":
+      return ErrorType.SERVER;
+    case "TypeError":
+      return ErrorType.NETWORK;
+    case "ConstraintViolationList":
+      return ErrorType.VALIDATION;
+    default:
+      return ErrorType.UNKNOWN;
+  }
+}
+export default function(errorState) {
+  return {
+    // use endpoint to make error be replace
+    error(event, error) {
+      const id = (/* @__PURE__ */ new Date()).getTime();
+      const err = { event, timestamp: id };
+      if (error.cause) {
+        err.type = getErrorType(error.cause.constructor.name);
+        err.detail = error.cause.message;
+      } else {
+        const detail = error.data?.["detail"] || error.data?.["description"];
+        if (detail) {
+          err.type = getErrorType(error.data["@type"] || error.data["type"]);
+          err.detail = detail;
+          err.violations = error.data.violations?.map((e) => ({ property: e.propertyPath, message: e.message }));
+        } else {
+          err.type = ErrorType.SERVER;
+          err.detail = error.data;
+        }
+      }
+      if (err.type === ErrorType.SERVER || err.type === ErrorType.VALIDATION || err.type === ErrorType.UNKNOWN) {
+        err.statusCode = error.statusCode;
+      }
+      errorState.byId[id] = err;
+      errorState.allIds.push(id);
+      errorState.allEndpoints.set(event.endpoint, id);
+    },
+    manual(error) {
+      const id = error.timestamp;
+      errorState.byId[id] = error;
+      errorState.allIds.push(id);
+      errorState.allEndpoints.set("unset", id);
+    },
+    clear() {
+      errorState.allIds = [];
+      errorState.allEndpoints.clear();
+      errorState.byId = {};
+    },
+    removeById(id) {
+      const err = errorState.byId[id];
+      if (!err) {
+        return;
+      }
+      delete errorState.byId[id];
+      errorState.allIds.splice(errorState.allIds.indexOf(id), 1);
+      const endpoint = err.event?.endpoint || "local";
+      if (endpoint) {
+        errorState.allEndpoints.delete(endpoint);
+      }
+    },
+    removeByEndpoint(endpoint) {
+      if (!errorState.allEndpoints.has(endpoint)) {
+        return;
+      }
+      const id = errorState.allEndpoints.get(endpoint);
+      id && this.removeById(id);
+    }
+  };
+}

package/dist/runtime/storage/stores/error/error-store.d.ts

@@ -0,0 +1,13 @@
+import type { CwaPiniaStoreDefinitionInterface, CwaPiniaStoreInterface, CwaStore } from '../cwa-store-types.js';
+import type { CwaErrorStateInterface } from './state.js';
+import type { CwaErrorActionsInterface } from './actions.js';
+import type { CwaErrorsGettersInterface } from './getters.js';
+export interface CwaErrorInterface extends CwaErrorStateInterface, CwaErrorActionsInterface, CwaErrorsGettersInterface {
+}
+export type CwaErrorStoreDefinitionInterface = CwaPiniaStoreDefinitionInterface<`${string}.error`, CwaErrorInterface>;
+export type CwaErrorStoreInterface = CwaPiniaStoreInterface<`${string}.error`, CwaErrorInterface>;
+export declare class ErrorStore implements CwaStore {
+    private readonly storeDefinition;
+    constructor(storeName: string);
+    useStore(): CwaErrorStoreInterface;
+}

package/dist/runtime/storage/stores/error/error-store.js

@@ -0,0 +1,21 @@
+import { defineStore } from "pinia";
+import CwaErrorState from "./state.js";
+import CwaErrorActions from "./actions.js";
+import CwaErrorGetters from "./getters.js";
+export class ErrorStore {
+  storeDefinition;
+  constructor(storeName) {
+    this.storeDefinition = defineStore(`${storeName}.error`, () => {
+      const errorState = CwaErrorState();
+      const getters = CwaErrorGetters(errorState);
+      return {
+        ...errorState,
+        ...getters,
+        ...CwaErrorActions(errorState)
+      };
+    });
+  }
+  useStore() {
+    return this.storeDefinition();
+  }
+}

package/dist/runtime/storage/stores/error/getters.d.ts

@@ -0,0 +1,7 @@
+import type { ComputedRef } from 'vue';
+import type { CwaErrorEvent, CwaErrorStateInterface } from './state.js';
+export interface CwaErrorsGettersInterface {
+    hasErrors: ComputedRef<boolean>;
+    getErrors: ComputedRef<CwaErrorEvent[]>;
+}
+export default function (errorsState: CwaErrorStateInterface): CwaErrorsGettersInterface;

package/dist/runtime/storage/stores/error/getters.js

@@ -0,0 +1,11 @@
+import { computed } from "vue";
+export default function(errorsState) {
+  return {
+    hasErrors: computed(() => {
+      return errorsState.allIds.length > 0;
+    }),
+    getErrors: computed(() => {
+      return errorsState.allIds.map((e) => errorsState.byId[e]).filter((e) => e !== void 0);
+    })
+  };
+}

package/dist/runtime/storage/stores/error/state.d.ts

@@ -0,0 +1,35 @@
+import type { ApiResourceEvent } from '../../../resources/resources-manager.js';
+export interface CwaViolationError {
+    message: string;
+    property: string;
+}
+export declare enum ErrorType {
+    NETWORK = "NETWORK",
+    VALIDATION = "VALIDATION",
+    SERVER = "SERVER",
+    UNKNOWN = "UNKNOWN"
+}
+interface CwaBaseErrorEvent {
+    event?: ApiResourceEvent;
+    detail: string;
+    violations: CwaViolationError[];
+    timestamp: number;
+}
+interface CwaResolvedErrorEvent extends CwaBaseErrorEvent {
+    type: Exclude<ErrorType, ErrorType.NETWORK>;
+    statusCode: number;
+}
+interface CwaNetworkErrorEvent extends CwaBaseErrorEvent {
+    type: ErrorType.NETWORK;
+    statusCode: undefined;
+}
+export type CwaErrorEvent = CwaNetworkErrorEvent | CwaResolvedErrorEvent;
+export interface CwaErrorStateInterface {
+    byId: {
+        [key: number]: CwaErrorEvent;
+    };
+    allIds: Array<number>;
+    allEndpoints: Map<string, number>;
+}
+export default function (): CwaErrorStateInterface;
+export {};

package/dist/runtime/storage/stores/error/state.js

@@ -0,0 +1,15 @@
+import { reactive } from "vue";
+export var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2["NETWORK"] = "NETWORK";
+  ErrorType2["VALIDATION"] = "VALIDATION";
+  ErrorType2["SERVER"] = "SERVER";
+  ErrorType2["UNKNOWN"] = "UNKNOWN";
+  return ErrorType2;
+})(ErrorType || {});
+export default function() {
+  return reactive({
+    byId: {},
+    allIds: [],
+    allEndpoints: /* @__PURE__ */ new Map()
+  });
+}

package/dist/runtime/storage/stores/fetcher/actions.d.ts

@@ -0,0 +1,56 @@
+import type { CwaResourceError } from '../../../errors/cwa-resource-error.js';
+import type { CwaFetcherStateInterface } from './state.js';
+import type { CwaFetcherGettersInterface } from './getters.js';
+import type { CwaFetchRequestHeaders } from '#cwa/api/fetcher/fetcher';
+export interface StartFetchEvent {
+    token?: string;
+    path: string;
+    manifestPath?: string;
+    isPrimary?: boolean;
+    isCurrentSuccessResourcesResolved: boolean;
+}
+export interface FinishFetchEvent {
+    token: string;
+}
+export interface AddFetchResourceEvent {
+    token: string;
+    resource: string;
+    path: string;
+    headers?: CwaFetchRequestHeaders;
+}
+export interface StartFetchResponse {
+    continue: boolean;
+    resources: string[];
+    token: string;
+}
+export declare enum FinishFetchManifestType {
+    SUCCESS = "SUCCESS",
+    ERROR = "ERROR"
+}
+export interface ManifestSuccessFetchEvent {
+    type: FinishFetchManifestType.SUCCESS;
+    token: string;
+}
+export interface SetManifestIrisByDepthEvent {
+    token: string;
+    irisByDepth: string[][];
+}
+export interface ManifestErrorFetchEvent {
+    type: FinishFetchManifestType.ERROR;
+    token: string;
+    error: CwaResourceError;
+}
+interface AbortFetchEvent {
+    token: string;
+}
+export interface CwaFetcherActionsInterface {
+    abortFetch(event: AbortFetchEvent): void;
+    setManifestIrisByDepth(event: SetManifestIrisByDepthEvent): void;
+    finishManifestFetch(event: ManifestSuccessFetchEvent | ManifestErrorFetchEvent): void;
+    startFetch(event: StartFetchEvent): StartFetchResponse;
+    finishFetch(event: FinishFetchEvent): void;
+    addFetchResource(event: AddFetchResourceEvent): boolean;
+    clearFetches(): void;
+}
+export default function (fetcherState: CwaFetcherStateInterface, fetcherGetters: CwaFetcherGettersInterface): CwaFetcherActionsInterface;
+export {};