@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/plugin/component/Plugin_Helpers.res.mjs

@@ -0,0 +1,1010 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Pulumi$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Pulumi.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Belt_SetString from "@rescript/runtime/lib/es6/Belt_SetString.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
+import * as Task$ReventlessCore from "../../components/Task/Task.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
+import * as Adapter$ReventlessCore from "../../adapter/Adapter.res.mjs";
+import * as Task$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/Task.res.mjs";
+import * as Aggregate$ReventlessCore from "../../components/Aggregate/Aggregate.res.mjs";
+import * as Component$ReventlessCore from "../../components/Component.res.mjs";
+import * as ReadModel$ReventlessCore from "../../components/ReadModel/ReadModel.res.mjs";
+import * as Api_Naming$ReventlessCore from "../../components/Api/Api_Naming.res.mjs";
+import * as PluginSpec$ReventlessCore from "../lifecycle/PluginSpec.res.mjs";
+import * as DcbEventLog$ReventlessCore from "../../components/DcbEventLog/DcbEventLog.res.mjs";
+import * as EventMapper$ReventlessCore from "../../components/EventMapper/EventMapper.res.mjs";
+import * as Aggregate$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/Aggregate.res.mjs";
+import * as ReadModel$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/ReadModel.res.mjs";
+import * as Util_QueryDb$ReventlessCore from "../../util/Util_QueryDb.res.mjs";
+import * as ComponentType$ReventlessCore from "../../ComponentType.res.mjs";
+import * as ExportMeta$ReventlessInterop from "@reventlessdev/reventless-interop/src/ExportMeta.res.mjs";
+import * as DcbEventLog$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/DcbEventLog.res.mjs";
+import * as EventCollector$ReventlessCore from "../../components/EventCollector/EventCollector.res.mjs";
+import * as EventMapper$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/EventMapper.res.mjs";
+import * as ExtensionPoint$ReventlessCore from "../../components/ExtensionPoint/ExtensionPoint.res.mjs";
+import * as StateViewSlice$ReventlessCore from "../../components/StateViewSlice/StateViewSlice.res.mjs";
+import * as Util_StackRefs$ReventlessCore from "../../util/Util_StackRefs.res.mjs";
+import * as ApiNoApiHelpers$ReventlessCore from "../../components/Api/ApiNoApiHelpers.res.mjs";
+import * as AutomationSlice$ReventlessCore from "../../components/AutomationSlice/AutomationSlice.res.mjs";
+import * as Builder_Helpers$ReventlessCore from "../../components/Builder_Helpers.res.mjs";
+import * as Plugin_Callback$ReventlessCore from "./Plugin_Callback.res.mjs";
+import * as Plugin_BuiltHook$ReventlessCore from "./Plugin_BuiltHook.res.mjs";
+import * as StateChangeSlice$ReventlessCore from "../../components/StateChangeSlice/StateChangeSlice.res.mjs";
+import * as ExtensionPoint$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/ExtensionPoint.res.mjs";
+import * as Extension_Builder$ReventlessCore from "../../components/Extension/Extension_Builder.res.mjs";
+import * as StateViewSlice$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/StateViewSlice.res.mjs";
+import * as AutomationSlice$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/AutomationSlice.res.mjs";
+import * as StateChangeSlice$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/StateChangeSlice.res.mjs";
+import * as ResourceQueryRuntime$ReventlessCore from "../../util/ResourceQueryRuntime.res.mjs";
+import * as EventCollector_Builder$ReventlessCore from "../../components/EventCollector/EventCollector_Builder.res.mjs";
+import * as InboundTranslationSlice$ReventlessCore from "../../components/InboundTranslationSlice/InboundTranslationSlice.res.mjs";
+import * as OutboundTranslationSlice$ReventlessCore from "../../components/OutboundTranslationSlice/OutboundTranslationSlice.res.mjs";
+import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
+import * as InboundTranslationSlice$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/InboundTranslationSlice.res.mjs";
+import * as OutboundTranslationSlice$ReventlessInterop from "@reventlessdev/reventless-interop/src/components/OutboundTranslationSlice.res.mjs";
+import * as PluginExtensionPoint_Plugin$ReventlessCore from "../connect/PluginExtensionPoint_Plugin.res.mjs";
+import * as PluginConnectExtension_Builder$ReventlessCore from "../connect/PluginConnectExtension_Builder.res.mjs";
+import * as PluginConnectExtension_Mapping$ReventlessCore from "../connect/PluginConnectExtension_Mapping.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function getRemoteStorageResources(pluginName, queryDbName) {
+  let resources = Stdlib_Option.map(Util_StackRefs$ReventlessCore.get(pluginName), stackRef => {
+    let readModelsOutput = stackRef.getOutput("readModels");
+    return readModelsOutput.apply(readModelsOpt => {
+      if (readModelsOpt === undefined) {
+        return [];
+      }
+      let dict = Stdlib_JSON.Decode.object(readModelsOpt);
+      if (dict === undefined) {
+        return [];
+      }
+      let rawReadModel = dict[queryDbName];
+      if (rawReadModel === undefined) {
+        return [];
+      }
+      try {
+        let readModel = S.parseOrThrow(rawReadModel, ReadModel$ReventlessInterop.resolvedOutputsSchema);
+        return Adapter$ReventlessCore.fromInteropResources(readModel.queryDb.resources);
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "parse error");
+        log.error("Plugin_Helpers", undefined, `getRemoteStorageResources: failed to parse readModel ` + queryDbName + ` from ` + pluginName + `: ` + msg);
+        return [];
+      }
+    });
+  });
+  if (resources !== undefined) {
+    return resources;
+  }
+  let known = Object.keys(Util_StackRefs$ReventlessCore.stackRefs).join(",");
+  log.error("Plugin_Helpers", undefined, `getRemoteStorageResources: plugin ` + pluginName + ` not found (check platform.stack config) known=[` + known + `]`);
+  return Pulumi.output([]);
+}
+
+function getStorageResources(allQueryDbs, pluginName, queryDbName) {
+  if (pluginName !== undefined) {
+    return getRemoteStorageResources(pluginName, queryDbName);
+  } else {
+    return Pulumi.output(Util_QueryDb$ReventlessCore.getLocalStorageResources(allQueryDbs, queryDbName));
+  }
+}
+
+let eventCollectorContextRef = {
+  contents: {}
+};
+
+function registerEventCollectorContext(componentName, context) {
+  eventCollectorContextRef.contents[componentName] = context;
+}
+
+let adminPluginExtensionPointSpecModule = "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
+
+function getIncomingJsonEventsHandler(jsonEventsHandlers) {
+  return jsonEventsHandlers.incoming;
+}
+
+function getOutgoingJsonEventsHandler(jsonEventsHandlers) {
+  return jsonEventsHandlers.outgoing;
+}
+
+function serviceNameToJsonEventsHandlers(outputs, getServiceNames, handlers, getEventHandler) {
+  let dict = {};
+  Stdlib_Array.zip(outputs, handlers).forEach(param => {
+    let outputs = param[0];
+    Stdlib_Option.forEach(getEventHandler(param[1]), jsonEventsHandler => {
+      getServiceNames(outputs).forEach(serviceName => {
+        let jsonEventsHandlers = dict[serviceName];
+        if (jsonEventsHandlers !== undefined) {
+          dict[serviceName] = jsonEventsHandlers.concat([jsonEventsHandler]);
+        } else {
+          dict[serviceName] = [jsonEventsHandler];
+        }
+      });
+    });
+  });
+  return dict;
+}
+
+function createExtensions(extensions, pluginName, publishToPluginExtensionPoint, publishToAggregates, publishToReadModels, queryEngine, opts) {
+  let groups = {};
+  extensions.forEach(bp => {
+    let epName = bp.Spec.name;
+    let existing = groups[epName];
+    if (existing !== undefined) {
+      existing.push(bp);
+    } else {
+      groups[epName] = [bp];
+    }
+  });
+  let triples = Object.entries(groups).map(param => {
+    let blueprints = param[1];
+    let First = blueprints[0];
+    let allMappings = blueprints.flatMap(bp => bp.mappings);
+    let Mappings_moduleUrl = First.moduleUrl;
+    let Mappings = {
+      name: pluginName,
+      moduleUrl: Mappings_moduleUrl,
+      mappings: allMappings
+    };
+    let ExtensionMaker = Extension_Builder$ReventlessCore.Make(First.Spec)(Mappings);
+    let extension = ExtensionMaker.make(publishToPluginExtensionPoint, publishToAggregates, Builder_Helpers$ReventlessCore.readModelNamesForSourceName, publishToReadModels, queryEngine, opts);
+    let ops = ExtensionMaker.operations(extension);
+    let registryInfo_specModule = First.Spec.moduleUrl;
+    let registryInfo_mappingsModule = First.moduleUrl;
+    let registryInfo_delegateModule = First.delegateModuleUrl;
+    let registryInfo = {
+      specModule: registryInfo_specModule,
+      mappingsModule: registryInfo_mappingsModule,
+      delegateModule: registryInfo_delegateModule
+    };
+    return [
+      ExtensionMaker.outputs(extension),
+      ops.apply(param => ({
+        outgoing: param.outgoingJsonEventsHandler,
+        incoming: param.incomingJsonEventsHandler
+      })),
+      registryInfo
+    ];
+  });
+  let outputs = triples.map(param => param[0]);
+  let handlers = triples.map(param => param[1]);
+  let registryInfos = triples.map(param => param[2]);
+  return [
+    outputs,
+    handlers,
+    registryInfos
+  ];
+}
+
+function extractExtensionPointDefinitions(extensionPointsOutputs) {
+  return Pulumi.all(extensionPointsOutputs.map(extensionPointOutputs => Pulumi.all([
+    Output$Pulumi.flatMap(extensionPointOutputs.commandTopic, param => {
+      let r = param.resources[0];
+      if (r !== undefined) {
+        return r.id;
+      } else {
+        return Pulumi.output("");
+      }
+    }),
+    Output$Pulumi.flatMap(extensionPointOutputs.eventTopic, param => {
+      let r = param.resources[0];
+      if (r !== undefined) {
+        return r.id;
+      } else {
+        return Pulumi.output("");
+      }
+    })
+  ]).apply(param => ({
+    name: extensionPointOutputs.name,
+    commandTopic: param[0],
+    eventTopic: param[1]
+  }))));
+}
+
+function extractExtensionDefinitions(extensionsOutputs) {
+  return extensionsOutputs.map(extensionOutputs => ({
+    name: extensionOutputs.name,
+    extensionPointName: extensionOutputs.extensionPointName,
+    dcbSources: []
+  }));
+}
+
+function createConnectPluginExtension(pluginDefinition, publishToPluginExtensionPoint, publishToAggregates, readModelNamesForSourceName, publishToReadModels, queryEngine, opts) {
+  return Output$Pulumi.unzip(pluginDefinition.apply(pluginDefinition => {
+    let ConnectPluginExtension = PluginConnectExtension_Builder$ReventlessCore.Make({
+      pluginDefinition: pluginDefinition
+    });
+    let connectPluginExtension = ConnectPluginExtension.make(publishToPluginExtensionPoint, publishToAggregates, readModelNamesForSourceName, publishToReadModels, queryEngine, opts);
+    let connectPluginExtensionOutputs = Component$ReventlessCore.outputs(connectPluginExtension);
+    let connectPluginExtensionIncomingEventHandler = Component$ReventlessCore.operations(connectPluginExtension).apply(param => param.incomingJsonEventsHandler);
+    return [
+      connectPluginExtensionOutputs,
+      connectPluginExtensionIncomingEventHandler
+    ];
+  }));
+}
+
+let tasksOutputs = {
+  contents: []
+};
+
+function createTasks(tasks, aggregatesOutputs, scheduler, schedulerRoleUrn, publishToAggregates, queryEngine, resourceNaming, opts) {
+  tasksOutputs.contents = tasks.map(SpecificTask => SpecificTask.outputs(SpecificTask.make((taskName, bucketNameOpt) => {
+    let bucketName = bucketNameOpt !== undefined ? bucketNameOpt : "Bucket";
+    return ResourceQueryRuntime$ReventlessCore.bucketNameOfTaskExn(tasksOutputs.contents, taskName, bucketName);
+  }, scheduler, schedulerRoleUrn, publishToAggregates, queryEngine, resourceNaming, aggregatesOutputs, opts)));
+  return tasksOutputs.contents;
+}
+
+function MakeEventCollectorHelper(RuntimeEnvironment) {
+  return EventCollectorChannel => (PluginRuntimeBuilder => {
+    let PluginEventCollector = EventCollector_Builder$ReventlessCore.Make(RuntimeEnvironment)(EventCollectorChannel);
+    let make = (name, eventTopics, opts) => {
+      let eventCollector = PluginEventCollector.make(name, eventTopics, opts);
+      let eventCollectorOutputs = Component$ReventlessCore.outputs(eventCollector);
+      let resources = eventCollectorOutputs.resources;
+      let r = resources[resources.length - 1 | 0];
+      let eventCollectorUrn = r !== undefined ? r.urn : Pulumi.output("");
+      return [
+        eventCollector,
+        eventCollectorOutputs,
+        eventCollectorUrn
+      ];
+    };
+    let connect = (eventCollector, eventTopics, extensionPointsOutputs, extensionsOutputs, pluginExtensionPointUnwrapped, pluginDefinition, connectPluginExtensionIncomingEventHandler, extensionsHandlers, extensionPointsHandlers, connectPluginExtensionOutputs, extensionRegistryInfosOpt, extensionPointRegistryInfosOpt, aggregateQueueUrlsOpt, readModelQueueUrlsOpt, readModelNamesForSourceNameOpt) => {
+      let extensionRegistryInfos = extensionRegistryInfosOpt !== undefined ? extensionRegistryInfosOpt : [];
+      let extensionPointRegistryInfos = extensionPointRegistryInfosOpt !== undefined ? extensionPointRegistryInfosOpt : [];
+      let aggregateQueueUrls = aggregateQueueUrlsOpt !== undefined ? aggregateQueueUrlsOpt : ({});
+      let readModelQueueUrls = readModelQueueUrlsOpt !== undefined ? readModelQueueUrlsOpt : ({});
+      let readModelNamesForSourceName = readModelNamesForSourceNameOpt !== undefined ? readModelNamesForSourceNameOpt : ({});
+      let resources = Pulumi.all(extensionPointsOutputs.map(extensionPoint => extensionPoint.eventTopic)).apply(eventTopics => {
+        let base = eventTopics.map(eventTopic => eventTopic.resources).flat();
+        if (pluginExtensionPointUnwrapped !== undefined) {
+          return base.concat(Adapter$ReventlessCore.fromInteropResources(pluginExtensionPointUnwrapped.commandTopic.resources));
+        } else {
+          return base;
+        }
+      });
+      let connectExtData = connectPluginExtensionIncomingEventHandler !== undefined && connectPluginExtensionOutputs !== undefined ? Pulumi.all([
+          connectPluginExtensionIncomingEventHandler,
+          connectPluginExtensionOutputs
+        ]).apply(param => [
+          param[0],
+          param[1]
+        ]) : Pulumi.output(undefined);
+      return Pulumi.all([
+        pluginDefinition,
+        connectExtData,
+        Pulumi.all(extensionsHandlers),
+        Pulumi.all(extensionPointsHandlers),
+        resources
+      ]).apply(param => {
+        let extensionsHandlers = param[2];
+        let connectExtData = param[1];
+        let pluginDefinition = param[0];
+        let incomingConnectExtensionEventHandlers = connectExtData !== undefined ? serviceNameToJsonEventsHandlers([connectExtData[1]], outputs => [outputs.extensionPointName], [{
+              incoming: connectExtData[0]
+            }], getIncomingJsonEventsHandler) : ({});
+        let outgoingExtensionPointEventHandlers = serviceNameToJsonEventsHandlers(extensionPointsOutputs, outputs => outputs.aggregateNames, param[3].map(extensionPointsHandler => ({
+          outgoing: extensionPointsHandler
+        })), getOutgoingJsonEventsHandler);
+        let outgoingExtensionEventHandlers = serviceNameToJsonEventsHandlers(extensionsOutputs, outputs => outputs.aggregateNames, extensionsHandlers, getOutgoingJsonEventsHandler);
+        let incomingExtensionEventHandlers = serviceNameToJsonEventsHandlers(extensionsOutputs, outputs => [outputs.extensionPointName], extensionsHandlers, getIncomingJsonEventsHandler);
+        let Callback = Plugin_Callback$ReventlessCore.Make({
+          pluginDefinition: pluginDefinition,
+          incomingConnectExtensionEventHandlers: incomingConnectExtensionEventHandlers,
+          outgoingExtensionPointEventHandlers: outgoingExtensionPointEventHandlers,
+          outgoingExtensionEventHandlers: outgoingExtensionEventHandlers,
+          incomingExtensionEventHandlers: incomingExtensionEventHandlers
+        });
+        let handler = PluginEventCollector.makeHandler(eventCollector, Callback.handleJsonEvents);
+        let ecResource = Component$ReventlessCore.toPulumiResource(eventCollector);
+        let ecName = ComponentType$ReventlessCore.nameOpt(ecResource.__name, EventCollector$ReventlessCore.componentType);
+        let pluginDefinitionJson = Pulumi.output(JSON.stringify(S.reverseConvertToJsonOrThrow(pluginDefinition, Plugin$Reventless.pluginDefinitionSchema)));
+        let pluginExtensionPointCmdTopicUrl;
+        if (pluginExtensionPointUnwrapped !== undefined) {
+          let r = pluginExtensionPointUnwrapped.commandTopic.resources[0];
+          pluginExtensionPointCmdTopicUrl = r !== undefined ? Pulumi.output(r.id) : Pulumi.output("");
+        } else {
+          pluginExtensionPointCmdTopicUrl = Pulumi.output("");
+        }
+        let connectExtension = connectExtData !== undefined ? ({
+            specModule: adminPluginExtensionPointSpecModule,
+            mappingsModule: PluginConnectExtension_Mapping$ReventlessCore.moduleUrl,
+            extensionPointName: PluginExtensionPointSpec$ReventlessInfra.name
+          }) : undefined;
+        let extensions = extensionsOutputs.length === extensionRegistryInfos.length ? extensionsOutputs.map((output, i) => {
+            let info = extensionRegistryInfos[i];
+            let rmNames = Stdlib_Option.getOr(readModelNamesForSourceName[output.extensionPointName], []);
+            return {
+              name: output.name,
+              specModule: info.specModule,
+              mappingsModule: info.mappingsModule,
+              delegateModule: info.delegateModule,
+              extensionPointName: output.extensionPointName,
+              aggregateNames: output.aggregateNames,
+              readModelNames: rmNames
+            };
+          }) : [];
+        let mergedAggregateUrls = {};
+        Object.entries(aggregateQueueUrls).forEach(param => {
+          mergedAggregateUrls[param[0]] = param[1];
+        });
+        if (connectExtData !== undefined) {
+          let match = mergedAggregateUrls[PluginSpec$ReventlessCore.name];
+          if (match !== undefined) {
+            
+          } else {
+            mergedAggregateUrls[PluginSpec$ReventlessCore.name] = pluginExtensionPointCmdTopicUrl;
+          }
+        }
+        let extensionPointEntries = extensionPointsOutputs.length === extensionPointRegistryInfos.length ? extensionPointsOutputs.map((output, i) => {
+            let info = extensionPointRegistryInfos[i];
+            let eventTopicArn = Output$Pulumi.flatMap(output.eventTopic, param => {
+              let r = param.resources[0];
+              if (r !== undefined) {
+                return r.id;
+              } else {
+                return Pulumi.output("");
+              }
+            });
+            return {
+              specModule: info.specModule,
+              mappingsModule: info.mappingsModule,
+              eventTopicArn: eventTopicArn,
+              aggregateNames: output.aggregateNames
+            };
+          }) : [];
+        registerEventCollectorContext(ecName, {
+          pluginDefinitionJson: pluginDefinitionJson,
+          extensionPoints: extensionPointEntries,
+          connectExtension: connectExtension,
+          extensions: extensions,
+          pluginExtensionPointCmdTopicUrl: pluginExtensionPointCmdTopicUrl,
+          publishToAggregates: mergedAggregateUrls,
+          readModelQueueUrls: readModelQueueUrls,
+          readModelNamesForSourceName: readModelNamesForSourceName
+        });
+        PluginRuntimeBuilder.forPluginEventCollector(handler, eventTopics, param[4], undefined, undefined, eventCollector);
+        let r$1 = Component$ReventlessCore.outputs(eventCollector).resources[0];
+        if (r$1 !== undefined) {
+          r$1.urn.apply(urn => {
+            pluginDefinition.eventCollector = urn;
+          });
+        } else {
+          Pulumi.output();
+        }
+      });
+    };
+    return {
+      PluginEventCollector: PluginEventCollector,
+      make: make,
+      connect: connect
+    };
+  });
+}
+
+let onPluginDeployedHook = {
+  contents: undefined
+};
+
+function registerOnPluginDeployed(hook) {
+  onPluginDeployedHook.contents = hook;
+}
+
+function clearOnPluginDeployed() {
+  onPluginDeployedHook.contents = undefined;
+}
+
+let onPlatformDeployedHook = {
+  contents: undefined
+};
+
+let lastPlatformDeployedInfo = {
+  contents: undefined
+};
+
+function registerOnPlatformDeployed(hook) {
+  onPlatformDeployedHook.contents = hook;
+}
+
+function firePlatformDeployedHook(info) {
+  lastPlatformDeployedInfo.contents = info;
+  let hook = onPlatformDeployedHook.contents;
+  if (hook !== undefined) {
+    return hook(info);
+  }
+}
+
+function replayPlatformDeployedHook() {
+  let match = onPlatformDeployedHook.contents;
+  let match$1 = lastPlatformDeployedInfo.contents;
+  if (match !== undefined && match$1 !== undefined) {
+    return match(match$1);
+  }
+}
+
+function clearOnPlatformDeployed() {
+  onPlatformDeployedHook.contents = undefined;
+  lastPlatformDeployedInfo.contents = undefined;
+}
+
+let queryFieldNamesRegistry = {};
+
+let stateSchemaRegistry = {};
+
+let aggregateMutationFieldsRegistry = {};
+
+let noHooks_adminExtensionPoints = {
+  contents: Pulumi.output({})
+};
+
+let noHooks_scheduler = {
+  contents: undefined
+};
+
+let noHooks_schedulerRoleUrn = {
+  contents: Pulumi.output("")
+};
+
+let noHooks_api = {
+  contents: undefined
+};
+
+let noHooks_apiRole = {
+  contents: undefined
+};
+
+let noHooks_deployTarget = {
+  contents: "Domain"
+};
+
+let noHooks = {
+  adminExtensionPoints: noHooks_adminExtensionPoints,
+  scheduler: noHooks_scheduler,
+  schedulerRoleUrn: noHooks_schedulerRoleUrn,
+  api: noHooks_api,
+  apiRole: noHooks_apiRole,
+  deployTarget: noHooks_deployTarget
+};
+
+let NoopHooksConfig = {
+  hooks: noHooks
+};
+
+function registerAdminAggregateMutations(aggregates, hooks) {
+  aggregates.forEach(M => {
+    let commandSchema = M.Spec.commandSchema;
+    if (ApiNoApiHelpers$ReventlessCore.isNoApi(commandSchema)) {
+      return;
+    }
+    let constructorNames = DcbTag$Reventless.extractAllVariantNames(M.Spec.commandSchema);
+    let filteredConstructorNames = ApiNoApiHelpers$ReventlessCore.filterNoApiVariants(constructorNames, commandSchema);
+    let fieldNames = filteredConstructorNames.map(cname => Api_Naming$ReventlessCore.adminField(M.Spec.name + "_" + cname));
+    aggregateMutationFieldsRegistry[M.Spec.name] = fieldNames;
+    if (fieldNames.length !== 0) {
+      return Stdlib_Option.forEach(hooks.mutationResolverHook, registerResolver => registerResolver("Aggregate", fieldNames, commandSchema, M.Spec.commandAuthorization));
+    }
+  });
+}
+
+let interopMetaOutput = {
+  contents: null
+};
+
+function taskFieldUnion(tasks) {
+  return Belt_SetString.toArray(Stdlib_Array.reduce(Object.values(tasks), undefined, (acc, taskOutput) => {
+    let match = taskOutput.bucketNames;
+    let match$1 = taskOutput.sideEffectSources;
+    let resolved = match !== undefined ? (
+        match$1 !== undefined ? ({
+            name: taskOutput.name,
+            bucketNames: {},
+            sideEffectSources: match$1
+          }) : ({
+            name: taskOutput.name,
+            bucketNames: {}
+          })
+      ) : (
+        match$1 !== undefined ? ({
+            name: taskOutput.name,
+            sideEffectSources: match$1
+          }) : ({
+            name: taskOutput.name
+          })
+      );
+    return Stdlib_Array.reduce(ExportMeta$ReventlessInterop.fieldNamesOf(resolved, Task$ReventlessInterop.resolvedOutputsSchema), acc, Belt_SetString.add);
+  }));
+}
+
+function toInteropMeta(outputs) {
+  let eventMapperMinimal_eventCollector = {
+    name: "",
+    resources: []
+  };
+  let eventMapperMinimal = {
+    name: "",
+    eventCollector: eventMapperMinimal_eventCollector
+  };
+  return {
+    version: ExportMeta$ReventlessInterop.version,
+    fields: Object.fromEntries([
+      [
+        "tasks",
+        taskFieldUnion(outputs.tasks)
+      ],
+      [
+        "eventMappers",
+        ExportMeta$ReventlessInterop.fieldNamesOf(eventMapperMinimal, EventMapper$ReventlessInterop.resolvedOutputsSchema)
+      ]
+    ])
+  };
+}
+
+function getInteropMeta() {
+  let v = interopMetaOutput.contents;
+  if ((v === null)) {
+    return Stdlib_JsError.throwWithMessage("getInteropMeta() called before Plugin_Builder.construct()");
+  } else {
+    return v;
+  }
+}
+
+function exportDeploymentMetadata() {
+  let metadata = Object.fromEntries([
+    [
+      "environment",
+      Pulumi.getStack()
+    ],
+    [
+      "region",
+      Stdlib_Option.getOr(new Pulumi.Config("aws").get("region"), "unknown")
+    ],
+    [
+      "timestamp",
+      new Date().toISOString()
+    ],
+    [
+      "gitSha",
+      Stdlib_Option.getOr(process.env["GITHUB_SHA"], "unknown")
+    ],
+    [
+      "actor",
+      Stdlib_Option.getOr(process.env["GITHUB_ACTOR"], "unknown")
+    ]
+  ]);
+  Pulumi$Pulumi.$$export("deploymentMetadata", Pulumi.output(Stdlib_Dict.mapValues(metadata, prim => prim)));
+}
+
+function serializePlainDictExport(dict, toResolved, schema) {
+  return Pulumi.all(Object.entries(dict).map(param => {
+    let name = param[0];
+    return toResolved(param[1]).apply(resolved => [
+      name,
+      S.reverseConvertToJsonOrThrow(resolved, schema)
+    ]);
+  })).apply(pairs => Object.fromEntries(pairs));
+}
+
+function serializeDictExport(dictOutput, toResolved, schema) {
+  return Output$Pulumi.flatMap(dictOutput, dict => Pulumi.all(Object.entries(dict).map(param => {
+    let name = param[0];
+    return toResolved(param[1]).apply(resolved => [
+      name,
+      S.reverseConvertToJsonOrThrow(resolved, schema)
+    ]);
+  })).apply(pairs => Object.fromEntries(pairs)));
+}
+
+function serializeTasksOutputs(pluginOutputs) {
+  return Output$Pulumi.flatMap(pluginOutputs.tasks, tasks => Pulumi.all(Object.values(tasks).map(task => Task$ReventlessCore.toResolvedOutputs(task).apply(resolved => S.reverseConvertToJsonOrThrow(resolved, Task$ReventlessInterop.resolvedOutputsSchema)))).apply(arr => arr));
+}
+
+function serializeEventMappersOutputs(pluginOutputs) {
+  return Output$Pulumi.flatMap(pluginOutputs.aggregates, aggregates => Pulumi.all(Stdlib_Array.filterMap(Object.values(aggregates), agg => Stdlib_Option.map(agg.eventMapper, eventMapperOutput => Output$Pulumi.flatMap(eventMapperOutput, em => EventMapper$ReventlessCore.toResolvedOutputs(em).apply(resolved => S.reverseConvertToJsonOrThrow(resolved, EventMapper$ReventlessInterop.resolvedOutputsSchema)))))).apply(arr => arr));
+}
+
+function exportPlatformOutputs(extensionPointsOutputs, aggregatesOutputs, readModelsOutputs, dcbEventLogOutputs, stateChangeSlicesOutputs, stateViewSlicesOutputs, automationSlicesOutputs, outboundTranslationSlicesOutputs, inboundTranslationSlicesOutputs) {
+  exportDeploymentMetadata();
+  Pulumi$Pulumi.$$export("extensionPoints", Output$Pulumi.flatMap(extensionPointsOutputs, eps => Pulumi.all(eps.map(ep => ExtensionPoint$ReventlessCore.toResolvedOutputs(ep).apply(resolved => [
+    ep.name,
+    S.reverseConvertToJsonOrThrow(resolved, ExtensionPoint$ReventlessInterop.resolvedOutputsSchema)
+  ]))).apply(pairs => Object.fromEntries(pairs))));
+  if (Object.keys(aggregatesOutputs).length !== 0) {
+    Pulumi$Pulumi.$$export("aggregates", serializePlainDictExport(aggregatesOutputs, Aggregate$ReventlessCore.toResolvedOutputs, Aggregate$ReventlessInterop.resolvedOutputsSchema));
+  }
+  if (Object.keys(readModelsOutputs).length !== 0) {
+    Pulumi$Pulumi.$$export("readModels", serializePlainDictExport(readModelsOutputs, ReadModel$ReventlessCore.toResolvedOutputs, ReadModel$ReventlessInterop.resolvedOutputsSchema));
+  }
+  if (dcbEventLogOutputs !== undefined) {
+    Pulumi$Pulumi.$$export("dcbEventLog", DcbEventLog$ReventlessCore.toResolvedOutputs(dcbEventLogOutputs).apply(resolved => S.reverseConvertToJsonOrThrow(resolved, DcbEventLog$ReventlessInterop.resolvedOutputsSchema)));
+  }
+  if (Object.keys(stateChangeSlicesOutputs).length !== 0) {
+    Pulumi$Pulumi.$$export("stateChangeSlices", serializePlainDictExport(stateChangeSlicesOutputs, StateChangeSlice$ReventlessCore.toResolvedOutputs, StateChangeSlice$ReventlessInterop.resolvedOutputsSchema));
+  }
+  if (Object.keys(stateViewSlicesOutputs).length !== 0) {
+    Pulumi$Pulumi.$$export("stateViewSlices", serializePlainDictExport(stateViewSlicesOutputs, StateViewSlice$ReventlessCore.toResolvedOutputs, StateViewSlice$ReventlessInterop.resolvedOutputsSchema));
+  }
+  if (Object.keys(automationSlicesOutputs).length !== 0) {
+    Pulumi$Pulumi.$$export("automationSlices", serializePlainDictExport(automationSlicesOutputs, AutomationSlice$ReventlessCore.toResolvedOutputs, AutomationSlice$ReventlessInterop.resolvedOutputsSchema));
+  }
+  if (Object.keys(outboundTranslationSlicesOutputs).length !== 0) {
+    Pulumi$Pulumi.$$export("outboundTranslationSlices", serializePlainDictExport(outboundTranslationSlicesOutputs, OutboundTranslationSlice$ReventlessCore.toResolvedOutputs, OutboundTranslationSlice$ReventlessInterop.resolvedOutputsSchema));
+  }
+  if (Object.keys(inboundTranslationSlicesOutputs).length !== 0) {
+    return Pulumi$Pulumi.$$export("inboundTranslationSlices", serializePlainDictExport(inboundTranslationSlicesOutputs, InboundTranslationSlice$ReventlessCore.toResolvedOutputs, InboundTranslationSlice$ReventlessInterop.resolvedOutputsSchema));
+  }
+}
+
+function exportPluginOutputs(pluginOutputs) {
+  exportDeploymentMetadata();
+  Pulumi$Pulumi.$$export("id", pluginOutputs.id.apply(v => v));
+  Pulumi$Pulumi.$$export("version", pluginOutputs.version.apply(v => v));
+  Pulumi$Pulumi.$$export("aggregates", serializeDictExport(pluginOutputs.aggregates, Aggregate$ReventlessCore.toResolvedOutputs, Aggregate$ReventlessInterop.resolvedOutputsSchema));
+  Pulumi$Pulumi.$$export("readModels", serializeDictExport(pluginOutputs.readModels, ReadModel$ReventlessCore.toResolvedOutputs, ReadModel$ReventlessInterop.resolvedOutputsSchema));
+  Pulumi$Pulumi.$$export("extensionPoints", serializeDictExport(pluginOutputs.extensionPoints, ExtensionPoint$ReventlessCore.toResolvedOutputs, ExtensionPoint$ReventlessInterop.resolvedOutputsSchema));
+  Pulumi$Pulumi.$$export("stateChangeSlices", serializeDictExport(pluginOutputs.stateChangeSlices, StateChangeSlice$ReventlessCore.toResolvedOutputs, StateChangeSlice$ReventlessInterop.resolvedOutputsSchema));
+  Pulumi$Pulumi.$$export("stateViewSlices", serializeDictExport(pluginOutputs.stateViewSlices, StateViewSlice$ReventlessCore.toResolvedOutputs, StateViewSlice$ReventlessInterop.resolvedOutputsSchema));
+  Pulumi$Pulumi.$$export("automationSlices", serializeDictExport(pluginOutputs.automationSlices, AutomationSlice$ReventlessCore.toResolvedOutputs, AutomationSlice$ReventlessInterop.resolvedOutputsSchema));
+  Pulumi$Pulumi.$$export("outboundTranslationSlices", serializeDictExport(pluginOutputs.outboundTranslationSlices, OutboundTranslationSlice$ReventlessCore.toResolvedOutputs, OutboundTranslationSlice$ReventlessInterop.resolvedOutputsSchema));
+  Pulumi$Pulumi.$$export("inboundTranslationSlices", serializeDictExport(pluginOutputs.inboundTranslationSlices, InboundTranslationSlice$ReventlessCore.toResolvedOutputs, InboundTranslationSlice$ReventlessInterop.resolvedOutputsSchema));
+  Pulumi$Pulumi.$$export("dcbEventLog", Output$Pulumi.flatMap(pluginOutputs.dcbEventLog, opt => {
+    if (opt !== undefined) {
+      return DcbEventLog$ReventlessCore.toResolvedOutputs(opt).apply(resolved => S.reverseConvertToJsonOrThrow(resolved, DcbEventLog$ReventlessInterop.resolvedOutputsSchema));
+    } else {
+      return Pulumi.output(null);
+    }
+  }));
+  Pulumi$Pulumi.$$export("tasks", serializeTasksOutputs(pluginOutputs));
+  Pulumi$Pulumi.$$export("eventMappers", serializeEventMappersOutputs(pluginOutputs));
+  let hook = onPluginDeployedHook.contents;
+  if (hook === undefined) {
+    return;
+  }
+  let actor = Stdlib_Option.getOr(Stdlib_Option.orElse(Stdlib_Option.orElse(process.env["GITHUB_ACTOR"], process.env["CI_COMMIT_AUTHOR"]), process.env["USER"]), "local");
+  let deploymentId = Stdlib_Option.getOr(Stdlib_Option.orElse(process.env["GITHUB_SHA"], process.env["CI_COMMIT_SHA"]), new Date().toISOString());
+  let resolveAggregates = Output$Pulumi.flatMap(pluginOutputs.aggregates, aggs => Pulumi.all(Object.entries(aggs).map(param => {
+    let name = param[0];
+    return Aggregate$ReventlessCore.toResolvedOutputs(param[1]).apply(resolved => ({
+      name: name,
+      kind: "Aggregate",
+      schema: Stdlib_Option.getOr(Plugin_BuiltHook$ReventlessCore.componentSchemaRegistry[name], {}),
+      resources: [],
+      subComponents: [
+        {
+          role: "commandGenerator",
+          resources: resolved.commandGenerator.resources
+        },
+        {
+          role: "commandTopic",
+          resources: resolved.commandTopic.resources
+        },
+        {
+          role: "eventLog",
+          resources: resolved.eventLog.resources
+        },
+        {
+          role: "eventTopic",
+          resources: resolved.eventLog.eventTopic.resources
+        }
+      ]
+    }));
+  })));
+  let resolveReadModels = Output$Pulumi.flatMap(pluginOutputs.readModels, rms => Pulumi.all(Object.entries(rms).map(param => {
+    let name = param[0];
+    return ReadModel$ReventlessCore.toResolvedOutputs(param[1]).apply(resolved => ({
+      name: name,
+      kind: "ReadModel",
+      schema: Stdlib_Option.getOr(Plugin_BuiltHook$ReventlessCore.componentSchemaRegistry[name], {}),
+      resources: [],
+      subComponents: [{
+          role: "queryDb",
+          resources: resolved.queryDb.resources
+        }]
+    }));
+  })));
+  let resolveExtensionPoints = Output$Pulumi.flatMap(pluginOutputs.extensionPoints, eps => Pulumi.all(Object.entries(eps).map(param => {
+    let name = param[0];
+    return ExtensionPoint$ReventlessCore.toResolvedOutputs(param[1]).apply(resolved => ({
+      name: name,
+      kind: "ExtensionPoint",
+      schema: Stdlib_Option.getOr(Plugin_BuiltHook$ReventlessCore.componentSchemaRegistry[name], {}),
+      resources: [],
+      subComponents: [
+        {
+          role: "commandTopic",
+          resources: resolved.commandTopic.resources
+        },
+        {
+          role: "eventTopic",
+          resources: resolved.eventTopic.resources
+        }
+      ]
+    }));
+  })));
+  let resolveStateChangeSlices = Output$Pulumi.flatMap(pluginOutputs.stateChangeSlices, slices => Pulumi.all(Object.entries(slices).map(param => {
+    let name = param[0];
+    return StateChangeSlice$ReventlessCore.toResolvedOutputs(param[1]).apply(resolved => ({
+      name: name,
+      kind: "StateChangeSlice",
+      schema: Stdlib_Option.getOr(Plugin_BuiltHook$ReventlessCore.componentSchemaRegistry[name], {}),
+      resources: resolved.resources,
+      subComponents: []
+    }));
+  })));
+  let resolveStateViewSlices = Output$Pulumi.flatMap(pluginOutputs.stateViewSlices, slices => Pulumi.all(Object.entries(slices).map(param => {
+    let name = param[0];
+    return StateViewSlice$ReventlessCore.toResolvedOutputs(param[1]).apply(resolved => ({
+      name: name,
+      kind: "StateViewSlice",
+      schema: Stdlib_Option.getOr(Plugin_BuiltHook$ReventlessCore.componentSchemaRegistry[name], {}),
+      resources: resolved.resources,
+      subComponents: [{
+          role: "queryDb",
+          resources: resolved.queryDb.resources
+        }]
+    }));
+  })));
+  let resolveAutomationSlices = Output$Pulumi.flatMap(pluginOutputs.automationSlices, slices => Pulumi.all(Object.entries(slices).map(param => {
+    let name = param[0];
+    return AutomationSlice$ReventlessCore.toResolvedOutputs(param[1]).apply(resolved => ({
+      name: name,
+      kind: "AutomationSlice",
+      schema: Stdlib_Option.getOr(Plugin_BuiltHook$ReventlessCore.componentSchemaRegistry[name], {}),
+      resources: resolved.resources,
+      subComponents: [{
+          role: "queryDb",
+          resources: resolved.queryDb.resources
+        }]
+    }));
+  })));
+  let resolveOutboundTranslationSlices = Output$Pulumi.flatMap(pluginOutputs.outboundTranslationSlices, slices => Pulumi.all(Object.entries(slices).map(param => {
+    let name = param[0];
+    return OutboundTranslationSlice$ReventlessCore.toResolvedOutputs(param[1]).apply(resolved => ({
+      name: name,
+      kind: "OutboundTranslationSlice",
+      schema: Stdlib_Option.getOr(Plugin_BuiltHook$ReventlessCore.componentSchemaRegistry[name], {}),
+      resources: resolved.resources,
+      subComponents: [{
+          role: "queryDb",
+          resources: resolved.queryDb.resources
+        }]
+    }));
+  })));
+  let resolveInboundTranslationSlices = Output$Pulumi.flatMap(pluginOutputs.inboundTranslationSlices, slices => Pulumi.all(Object.entries(slices).map(param => {
+    let name = param[0];
+    return InboundTranslationSlice$ReventlessCore.toResolvedOutputs(param[1]).apply(resolved => ({
+      name: name,
+      kind: "InboundTranslationSlice",
+      schema: Stdlib_Option.getOr(Plugin_BuiltHook$ReventlessCore.componentSchemaRegistry[name], {}),
+      resources: resolved.resources,
+      subComponents: [{
+          role: "queryDb",
+          resources: resolved.queryDb.resources
+        }]
+    }));
+  })));
+  let resolveDcbEventLog = Output$Pulumi.flatMap(pluginOutputs.dcbEventLog, opt => {
+    if (opt !== undefined) {
+      return DcbEventLog$ReventlessCore.toResolvedOutputs(opt).apply(resolved => [{
+          name: "DcbEventLog",
+          kind: "DcbEventLog",
+          schema: Stdlib_Option.getOr(Plugin_BuiltHook$ReventlessCore.componentSchemaRegistry["DcbEventLog"], {}),
+          resources: resolved.resources,
+          subComponents: [{
+              role: "eventTopic",
+              resources: resolved.eventTopic.resources
+            }]
+        }]);
+    } else {
+      return Pulumi.output([]);
+    }
+  });
+  let resolveExtensionWirings = Output$Pulumi.flatMap(pluginOutputs.extensions, exts => pluginOutputs.id.apply(id => {
+    let pluginName = id.split("@")[0];
+    let pluginVersion = id.split("@")[1];
+    return Object.values(exts).map(ext => {
+      let providerPlugin = ext.extensionPointName.split(".")[0];
+      return {
+        extensionName: ext.name,
+        extensionPointName: ext.extensionPointName,
+        providerPlugin: providerPlugin,
+        providerVersion: "",
+        subscriberPlugin: pluginName,
+        subscriberVersion: pluginVersion
+      };
+    });
+  }));
+  let hookOutput = Output$Pulumi.flatMap(Output$Pulumi.flatMap(Pulumi.all([
+    pluginOutputs.id,
+    pluginOutputs.version,
+    resolveAggregates,
+    resolveReadModels,
+    resolveExtensionPoints,
+    resolveStateChangeSlices
+  ]), param => {
+    let scs = param[5];
+    let eps = param[4];
+    let rms = param[3];
+    let aggs = param[2];
+    let version = param[1];
+    let id = param[0];
+    return Pulumi.all([
+      resolveStateViewSlices,
+      resolveAutomationSlices,
+      resolveOutboundTranslationSlices,
+      resolveInboundTranslationSlices,
+      resolveDcbEventLog,
+      resolveExtensionWirings
+    ]).apply(param => {
+      let name = id.split("@")[0];
+      let meta = Plugin_BuiltHook$ReventlessCore.pluginMetadataRegistry.contents;
+      return hook({
+        name: name,
+        version: version,
+        environment: Pulumi.getStack(),
+        stackName: Pulumi.getStack(),
+        deployedAt: new Date().toISOString(),
+        actor: actor,
+        deploymentId: deploymentId,
+        kind: Stdlib_Option.flatMap(meta, m => m.kind),
+        displayName: Stdlib_Option.flatMap(meta, m => m.displayName),
+        vendor: Stdlib_Option.flatMap(meta, m => m.vendor),
+        architectureType: Stdlib_Option.flatMap(meta, m => m.architectureType),
+        components: [
+          aggs,
+          rms,
+          eps,
+          scs,
+          param[0],
+          param[1],
+          param[2],
+          param[3],
+          param[4]
+        ].flat(),
+        extensionWirings: param[5]
+      });
+    });
+  }), p => p);
+  Pulumi$Pulumi.$$export("_pluginDeployedSync", hookOutput);
+}
+
+let adminPluginExtensionPointMappingsModule = PluginExtensionPoint_Plugin$ReventlessCore.moduleUrl;
+
+let pluginConnectExtensionMappingsModule = PluginConnectExtension_Mapping$ReventlessCore.moduleUrl;
+
+let addEventMapperFns = Builder_Helpers$ReventlessCore.addEventMapperFns;
+
+let aggregateResources = Builder_Helpers$ReventlessCore.aggregateResources;
+
+let publishToAggregates = Builder_Helpers$ReventlessCore.publishToAggregates;
+
+let aggregateFinishFns = Builder_Helpers$ReventlessCore.aggregateFinishFns;
+
+let createAggregatesWithoutEventMappers = Builder_Helpers$ReventlessCore.createAggregatesWithoutEventMappers;
+
+let finishAggregates = Builder_Helpers$ReventlessCore.finishAggregates;
+
+let addEventMappers = Builder_Helpers$ReventlessCore.addEventMappers;
+
+let readModelNamesForSourceName = Builder_Helpers$ReventlessCore.readModelNamesForSourceName;
+
+let publishToReadModels = Builder_Helpers$ReventlessCore.publishToReadModels;
+
+let finishReadModels = Builder_Helpers$ReventlessCore.finishReadModels;
+
+let extractReadModelsOutputs = Builder_Helpers$ReventlessCore.extractReadModelsOutputs;
+
+let createReadModels = Builder_Helpers$ReventlessCore.createReadModels;
+
+let createExtensionPoints = Builder_Helpers$ReventlessCore.createExtensionPoints;
+
+let createResolvers = Builder_Helpers$ReventlessCore.createResolvers;
+
+let ApiNoApi;
+
+let isNoApi = ApiNoApiHelpers$ReventlessCore.isNoApi;
+
+let getExcludedVariants = ApiNoApiHelpers$ReventlessCore.getExcludedVariants;
+
+let filterNoApiVariants = ApiNoApiHelpers$ReventlessCore.filterNoApiVariants;
+
+let componentSchemaRegistry = Plugin_BuiltHook$ReventlessCore.componentSchemaRegistry;
+
+let pluginMetadataRegistry = Plugin_BuiltHook$ReventlessCore.pluginMetadataRegistry;
+
+let registerPluginMetadata = Plugin_BuiltHook$ReventlessCore.registerPluginMetadata;
+
+let clearPluginMetadata = Plugin_BuiltHook$ReventlessCore.clearPluginMetadata;
+
+let onPluginBuiltHook = Plugin_BuiltHook$ReventlessCore.onPluginBuiltHook;
+
+let registerOnPluginBuilt = Plugin_BuiltHook$ReventlessCore.registerOnPluginBuilt;
+
+let clearOnPluginBuilt = Plugin_BuiltHook$ReventlessCore.clearOnPluginBuilt;
+
+export {
+  log,
+  getRemoteStorageResources,
+  getStorageResources,
+  eventCollectorContextRef,
+  registerEventCollectorContext,
+  adminPluginExtensionPointSpecModule,
+  adminPluginExtensionPointMappingsModule,
+  pluginConnectExtensionMappingsModule,
+  getIncomingJsonEventsHandler,
+  getOutgoingJsonEventsHandler,
+  serviceNameToJsonEventsHandlers,
+  addEventMapperFns,
+  aggregateResources,
+  publishToAggregates,
+  aggregateFinishFns,
+  createAggregatesWithoutEventMappers,
+  finishAggregates,
+  addEventMappers,
+  readModelNamesForSourceName,
+  publishToReadModels,
+  finishReadModels,
+  extractReadModelsOutputs,
+  createReadModels,
+  createExtensionPoints,
+  createResolvers,
+  ApiNoApi,
+  isNoApi,
+  getExcludedVariants,
+  filterNoApiVariants,
+  createExtensions,
+  extractExtensionPointDefinitions,
+  extractExtensionDefinitions,
+  createConnectPluginExtension,
+  tasksOutputs,
+  createTasks,
+  MakeEventCollectorHelper,
+  componentSchemaRegistry,
+  pluginMetadataRegistry,
+  registerPluginMetadata,
+  clearPluginMetadata,
+  onPluginBuiltHook,
+  registerOnPluginBuilt,
+  clearOnPluginBuilt,
+  onPluginDeployedHook,
+  registerOnPluginDeployed,
+  clearOnPluginDeployed,
+  onPlatformDeployedHook,
+  lastPlatformDeployedInfo,
+  registerOnPlatformDeployed,
+  firePlatformDeployedHook,
+  replayPlatformDeployedHook,
+  clearOnPlatformDeployed,
+  queryFieldNamesRegistry,
+  stateSchemaRegistry,
+  aggregateMutationFieldsRegistry,
+  noHooks,
+  NoopHooksConfig,
+  registerAdminAggregateMutations,
+  interopMetaOutput,
+  taskFieldUnion,
+  toInteropMeta,
+  getInteropMeta,
+  exportDeploymentMetadata,
+  serializePlainDictExport,
+  serializeDictExport,
+  serializeTasksOutputs,
+  serializeEventMappersOutputs,
+  exportPlatformOutputs,
+  exportPluginOutputs,
+}
+/* log Not a pure module */