@globalart/nestjs-temporal 1.1.5 → 1.2.1

package/dist/index.cjs

@@ -1,7 +1,4 @@
-//#region rolldown:runtime
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-
-//#endregion
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 let _nestjs_common = require("@nestjs/common");
 let _nestjs_core = require("@nestjs/core");
 let rxjs = require("rxjs");
@@ -10,21 +7,21 @@ let _temporalio_activity = require("@temporalio/activity");
 let _temporalio_client = require("@temporalio/client");
 let _nestjs_common_constants = require("@nestjs/common/constants");
 
-//#region src/temporal.constants.ts
+//#region src/constants/temporal.constants.ts
 const TEMPORAL_MODULE_ACTIVITIES = "_temporal_module_activities";
 const TEMPORAL_MODULE_ACTIVITY = "_temporal_module_activity";
 const TEMPORAL_MODULE_WORKFLOW = "_temporal_module_workFlow";
 const TEMPORAL_MODULE_WORKFLOW_METHOD = "_temporal_module_workflow_method";
-const TEMPORAL_ARGS_METADATA = "temporal:args";
+const TEMPORAL_ARGS_METADATA = "_temporal_module_args";
 
 //#endregion
-//#region \0@oxc-project+runtime@0.107.0/helpers/decorateMetadata.js
+//#region \0@oxc-project+runtime@0.112.0/helpers/decorateMetadata.js
 function __decorateMetadata(k, v) {
 	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 
 //#endregion
-//#region \0@oxc-project+runtime@0.107.0/helpers/decorate.js
+//#region \0@oxc-project+runtime@0.112.0/helpers/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -35,7 +32,7 @@ function __decorate(decorators, target, key, desc) {
 //#endregion
 //#region src/temporal-metadata.accessors.ts
 var _ref$1;
-let TemporalMetadataAccessor = class TemporalMetadataAccessor$1 {
+let TemporalMetadataAccessor = class TemporalMetadataAccessor {
 	constructor(reflector) {
 		this.reflector = reflector;
 	}
@@ -76,14 +73,14 @@ const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN: TEMPORAL_MODULE_OPTIONS_T
 
 //#endregion
 //#region src/temporal-enums.ts
-let TemporalParamType = /* @__PURE__ */ function(TemporalParamType$1) {
-	TemporalParamType$1[TemporalParamType$1["PAYLOAD"] = 3] = "PAYLOAD";
-	TemporalParamType$1[TemporalParamType$1["CONTEXT"] = 4] = "CONTEXT";
-	return TemporalParamType$1;
+let TemporalParamType = /* @__PURE__ */ function(TemporalParamType) {
+	TemporalParamType[TemporalParamType["PAYLOAD"] = 3] = "PAYLOAD";
+	TemporalParamType[TemporalParamType["CONTEXT"] = 4] = "CONTEXT";
+	return TemporalParamType;
 }({});
 
 //#endregion
-//#region src/temporal-execution-context.ts
+//#region src/core/temporal-execution-context.ts
 var TemporalExecutionContext = class {
 	constructor(instance, handler, args) {
 		this.instance = instance;
@@ -138,11 +135,11 @@ var TemporalParamsFactory = class {
 //#endregion
 //#region src/temporal.explorer.ts
 var _ref, _ref2, _ref3, _ref4, _TemporalExplorer;
-let TemporalExplorer = _TemporalExplorer = class TemporalExplorer$1 {
+let TemporalExplorer = _TemporalExplorer = class TemporalExplorer {
 	options;
 	logger = new _nestjs_common.Logger(_TemporalExplorer.name);
-	worker;
-	workerRunPromise;
+	workers;
+	workerRunPromises;
 	constructor(discoveryService, metadataAccessor, metadataScanner, externalContextCreator) {
 		this.discoveryService = discoveryService;
 		this.metadataAccessor = metadataAccessor;
@@ -159,19 +156,19 @@ let TemporalExplorer = _TemporalExplorer = class TemporalExplorer$1 {
 	* Shuts down the Temporal worker when the module is destroyed.
 	*/
 	async onModuleDestroy() {
-		if (!this.worker) return;
+		if (!this.workers) return;
 		try {
-			this.worker.shutdown();
-			if (this.workerRunPromise) await this.workerRunPromise;
+			this.workers.forEach((worker) => worker.shutdown());
+			if (this.workerRunPromises) await Promise.all(this.workers.map((worker) => worker.run()));
 		} catch (err) {
-			this.logger.warn("Temporal worker was not cleanly shutdown.", { err: err instanceof Error ? err.message : String(err) });
+			this.logger.warn("Temporal workers were not cleanly shutdown.", { err: err instanceof Error ? err.message : String(err) });
 		}
 	}
 	/**
 	* Starts the Temporal worker when the application is fully bootstrapped.
 	*/
 	onApplicationBootstrap() {
-		if (this.worker) this.workerRunPromise = this.worker.run();
+		if (this.workers) this.workerRunPromises = this.workers.map((worker) => worker.run());
 	}
 	/**
 	* Explores the application for Temporal activities and creates the worker.
@@ -181,7 +178,7 @@ let TemporalExplorer = _TemporalExplorer = class TemporalExplorer$1 {
 		const workerConfig = this.getWorkerConfigOptions();
 		const runTimeOptions = this.getRuntimeOptions();
 		const connectionOptions = this.getNativeConnectionOptions();
-		if (!workerConfig.taskQueue) {
+		if (workerConfig.some((workerConfig) => !workerConfig.taskQueue)) {
 			this.logger.warn("Temporal worker configuration missing taskQueue. Worker will not be created.");
 			return;
 		}
@@ -197,10 +194,12 @@ let TemporalExplorer = _TemporalExplorer = class TemporalExplorer$1 {
 			workerOptions.connection = await _temporalio_worker.NativeConnection.connect(connectionOptions);
 		}
 		this.logger.verbose("Creating a new Worker");
-		this.worker = await _temporalio_worker.Worker.create({
-			...workerConfig,
-			...workerOptions
-		});
+		this.workers = await Promise.all(workerConfig.map(async (workerConfig) => {
+			return _temporalio_worker.Worker.create({
+				...workerConfig,
+				...workerOptions
+			});
+		}));
 	}
 	/**
 	* Gets the worker configuration options.
@@ -266,7 +265,6 @@ let TemporalExplorer = _TemporalExplorer = class TemporalExplorer$1 {
 					if (isRequestScoped) this.logger.warn(`Request-scoped activities are not yet fully supported. Activity "${key}" from class "${instance.constructor.name}" may not work correctly.`);
 					const paramsFactory = new TemporalParamsFactory(instance, instance[key]);
 					const handler = this.externalContextCreator.create(instance, instance[key], key, TEMPORAL_ARGS_METADATA, paramsFactory, void 0, void 0, void 0, "temporal");
-					Reflect.defineMetadata(TEMPORAL_ARGS_METADATA, paramsFactory, instance[key]);
 					activitiesMethod[key] = async (...args) => {
 						const result = handler(...args, _temporalio_activity.Context.current().info);
 						return (0, rxjs.isObservable)(result) ? await (0, rxjs.lastValueFrom)(result) : await result;
@@ -358,7 +356,7 @@ function createClientAsyncProvider(asyncOptions) {
 //#endregion
 //#region src/temporal.module.ts
 var _TemporalModule;
-let TemporalModule = _TemporalModule = class TemporalModule$1 extends ConfigurableModuleClass {
+let TemporalModule = _TemporalModule = class TemporalModule extends ConfigurableModuleClass {
 	/**
 	* Registers a Temporal worker asynchronously.
 	* Useful when configuration depends on other async providers (e.g., ConfigService).
@@ -443,1265 +441,17 @@ function Workflows(nameOrOptions) {
 	};
 }
 
-//#endregion
-//#region ../../node_modules/.pnpm/reflect-metadata@0.2.2/node_modules/reflect-metadata/Reflect.js
-var require_Reflect = /* @__PURE__ */ __commonJSMin((() => {
-	/*! *****************************************************************************
-	Copyright (C) Microsoft. All rights reserved.
-	Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-	this file except in compliance with the License. You may obtain a copy of the
-	License at http://www.apache.org/licenses/LICENSE-2.0
-	
-	THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-	KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-	WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-	MERCHANTABLITY OR NON-INFRINGEMENT.
-	
-	See the Apache Version 2.0 License for specific language governing permissions
-	and limitations under the License.
-	***************************************************************************** */
-	var Reflect;
-	(function(Reflect$1) {
-		(function(factory) {
-			var root = typeof globalThis === "object" ? globalThis : typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
-			var exporter = makeExporter(Reflect$1);
-			if (typeof root.Reflect !== "undefined") exporter = makeExporter(root.Reflect, exporter);
-			factory(exporter, root);
-			if (typeof root.Reflect === "undefined") root.Reflect = Reflect$1;
-			function makeExporter(target, previous) {
-				return function(key, value) {
-					Object.defineProperty(target, key, {
-						configurable: true,
-						writable: true,
-						value
-					});
-					if (previous) previous(key, value);
-				};
-			}
-			function functionThis() {
-				try {
-					return Function("return this;")();
-				} catch (_) {}
-			}
-			function indirectEvalThis() {
-				try {
-					return (0, eval)("(function() { return this; })()");
-				} catch (_) {}
-			}
-			function sloppyModeThis() {
-				return functionThis() || indirectEvalThis();
-			}
-		})(function(exporter, root) {
-			var hasOwn = Object.prototype.hasOwnProperty;
-			var supportsSymbol = typeof Symbol === "function";
-			var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
-			var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
-			var supportsCreate = typeof Object.create === "function";
-			var supportsProto = { __proto__: [] } instanceof Array;
-			var downLevel = !supportsCreate && !supportsProto;
-			var HashMap = {
-				create: supportsCreate ? function() {
-					return MakeDictionary(Object.create(null));
-				} : supportsProto ? function() {
-					return MakeDictionary({ __proto__: null });
-				} : function() {
-					return MakeDictionary({});
-				},
-				has: downLevel ? function(map, key) {
-					return hasOwn.call(map, key);
-				} : function(map, key) {
-					return key in map;
-				},
-				get: downLevel ? function(map, key) {
-					return hasOwn.call(map, key) ? map[key] : void 0;
-				} : function(map, key) {
-					return map[key];
-				}
-			};
-			var functionPrototype = Object.getPrototypeOf(Function);
-			var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
-			var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
-			var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
-			var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : void 0;
-			var metadataRegistry = GetOrCreateMetadataRegistry();
-			var metadataProvider = CreateMetadataProvider(metadataRegistry);
-			/**
-			* Applies a set of decorators to a property of a target object.
-			* @param decorators An array of decorators.
-			* @param target The target object.
-			* @param propertyKey (Optional) The property key to decorate.
-			* @param attributes (Optional) The property descriptor for the target key.
-			* @remarks Decorators are applied in reverse order.
-			* @example
-			*
-			*     class Example {
-			*         // property declarations are not part of ES6, though they are valid in TypeScript:
-			*         // static staticProperty;
-			*         // property;
-			*
-			*         constructor(p) { }
-			*         static staticMethod(p) { }
-			*         method(p) { }
-			*     }
-			*
-			*     // constructor
-			*     Example = Reflect.decorate(decoratorsArray, Example);
-			*
-			*     // property (on constructor)
-			*     Reflect.decorate(decoratorsArray, Example, "staticProperty");
-			*
-			*     // property (on prototype)
-			*     Reflect.decorate(decoratorsArray, Example.prototype, "property");
-			*
-			*     // method (on constructor)
-			*     Object.defineProperty(Example, "staticMethod",
-			*         Reflect.decorate(decoratorsArray, Example, "staticMethod",
-			*             Object.getOwnPropertyDescriptor(Example, "staticMethod")));
-			*
-			*     // method (on prototype)
-			*     Object.defineProperty(Example.prototype, "method",
-			*         Reflect.decorate(decoratorsArray, Example.prototype, "method",
-			*             Object.getOwnPropertyDescriptor(Example.prototype, "method")));
-			*
-			*/
-			function decorate(decorators, target, propertyKey, attributes) {
-				if (!IsUndefined(propertyKey)) {
-					if (!IsArray(decorators)) throw new TypeError();
-					if (!IsObject(target)) throw new TypeError();
-					if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes)) throw new TypeError();
-					if (IsNull(attributes)) attributes = void 0;
-					propertyKey = ToPropertyKey(propertyKey);
-					return DecorateProperty(decorators, target, propertyKey, attributes);
-				} else {
-					if (!IsArray(decorators)) throw new TypeError();
-					if (!IsConstructor(target)) throw new TypeError();
-					return DecorateConstructor(decorators, target);
-				}
-			}
-			exporter("decorate", decorate);
-			/**
-			* A default metadata decorator factory that can be used on a class, class member, or parameter.
-			* @param metadataKey The key for the metadata entry.
-			* @param metadataValue The value for the metadata entry.
-			* @returns A decorator function.
-			* @remarks
-			* If `metadataKey` is already defined for the target and target key, the
-			* metadataValue for that key will be overwritten.
-			* @example
-			*
-			*     // constructor
-			*     @Reflect.metadata(key, value)
-			*     class Example {
-			*     }
-			*
-			*     // property (on constructor, TypeScript only)
-			*     class Example {
-			*         @Reflect.metadata(key, value)
-			*         static staticProperty;
-			*     }
-			*
-			*     // property (on prototype, TypeScript only)
-			*     class Example {
-			*         @Reflect.metadata(key, value)
-			*         property;
-			*     }
-			*
-			*     // method (on constructor)
-			*     class Example {
-			*         @Reflect.metadata(key, value)
-			*         static staticMethod() { }
-			*     }
-			*
-			*     // method (on prototype)
-			*     class Example {
-			*         @Reflect.metadata(key, value)
-			*         method() { }
-			*     }
-			*
-			*/
-			function metadata(metadataKey, metadataValue) {
-				function decorator(target, propertyKey) {
-					if (!IsObject(target)) throw new TypeError();
-					if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey)) throw new TypeError();
-					OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
-				}
-				return decorator;
-			}
-			exporter("metadata", metadata);
-			/**
-			* Define a unique metadata entry on the target.
-			* @param metadataKey A key used to store and retrieve metadata.
-			* @param metadataValue A value that contains attached metadata.
-			* @param target The target object on which to define metadata.
-			* @param propertyKey (Optional) The property key for the target.
-			* @example
-			*
-			*     class Example {
-			*         // property declarations are not part of ES6, though they are valid in TypeScript:
-			*         // static staticProperty;
-			*         // property;
-			*
-			*         constructor(p) { }
-			*         static staticMethod(p) { }
-			*         method(p) { }
-			*     }
-			*
-			*     // constructor
-			*     Reflect.defineMetadata("custom:annotation", options, Example);
-			*
-			*     // property (on constructor)
-			*     Reflect.defineMetadata("custom:annotation", options, Example, "staticProperty");
-			*
-			*     // property (on prototype)
-			*     Reflect.defineMetadata("custom:annotation", options, Example.prototype, "property");
-			*
-			*     // method (on constructor)
-			*     Reflect.defineMetadata("custom:annotation", options, Example, "staticMethod");
-			*
-			*     // method (on prototype)
-			*     Reflect.defineMetadata("custom:annotation", options, Example.prototype, "method");
-			*
-			*     // decorator factory as metadata-producing annotation.
-			*     function MyAnnotation(options): Decorator {
-			*         return (target, key?) => Reflect.defineMetadata("custom:annotation", options, target, key);
-			*     }
-			*
-			*/
-			function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
-				if (!IsObject(target)) throw new TypeError();
-				if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-				return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
-			}
-			exporter("defineMetadata", defineMetadata);
-			/**
-			* Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
-			* @param metadataKey A key used to store and retrieve metadata.
-			* @param target The target object on which the metadata is defined.
-			* @param propertyKey (Optional) The property key for the target.
-			* @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`.
-			* @example
-			*
-			*     class Example {
-			*         // property declarations are not part of ES6, though they are valid in TypeScript:
-			*         // static staticProperty;
-			*         // property;
-			*
-			*         constructor(p) { }
-			*         static staticMethod(p) { }
-			*         method(p) { }
-			*     }
-			*
-			*     // constructor
-			*     result = Reflect.hasMetadata("custom:annotation", Example);
-			*
-			*     // property (on constructor)
-			*     result = Reflect.hasMetadata("custom:annotation", Example, "staticProperty");
-			*
-			*     // property (on prototype)
-			*     result = Reflect.hasMetadata("custom:annotation", Example.prototype, "property");
-			*
-			*     // method (on constructor)
-			*     result = Reflect.hasMetadata("custom:annotation", Example, "staticMethod");
-			*
-			*     // method (on prototype)
-			*     result = Reflect.hasMetadata("custom:annotation", Example.prototype, "method");
-			*
-			*/
-			function hasMetadata(metadataKey, target, propertyKey) {
-				if (!IsObject(target)) throw new TypeError();
-				if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-				return OrdinaryHasMetadata(metadataKey, target, propertyKey);
-			}
-			exporter("hasMetadata", hasMetadata);
-			/**
-			* Gets a value indicating whether the target object has the provided metadata key defined.
-			* @param metadataKey A key used to store and retrieve metadata.
-			* @param target The target object on which the metadata is defined.
-			* @param propertyKey (Optional) The property key for the target.
-			* @returns `true` if the metadata key was defined on the target object; otherwise, `false`.
-			* @example
-			*
-			*     class Example {
-			*         // property declarations are not part of ES6, though they are valid in TypeScript:
-			*         // static staticProperty;
-			*         // property;
-			*
-			*         constructor(p) { }
-			*         static staticMethod(p) { }
-			*         method(p) { }
-			*     }
-			*
-			*     // constructor
-			*     result = Reflect.hasOwnMetadata("custom:annotation", Example);
-			*
-			*     // property (on constructor)
-			*     result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticProperty");
-			*
-			*     // property (on prototype)
-			*     result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "property");
-			*
-			*     // method (on constructor)
-			*     result = Reflect.hasOwnMetadata("custom:annotation", Example, "staticMethod");
-			*
-			*     // method (on prototype)
-			*     result = Reflect.hasOwnMetadata("custom:annotation", Example.prototype, "method");
-			*
-			*/
-			function hasOwnMetadata(metadataKey, target, propertyKey) {
-				if (!IsObject(target)) throw new TypeError();
-				if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-				return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
-			}
-			exporter("hasOwnMetadata", hasOwnMetadata);
-			/**
-			* Gets the metadata value for the provided metadata key on the target object or its prototype chain.
-			* @param metadataKey A key used to store and retrieve metadata.
-			* @param target The target object on which the metadata is defined.
-			* @param propertyKey (Optional) The property key for the target.
-			* @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-			* @example
-			*
-			*     class Example {
-			*         // property declarations are not part of ES6, though they are valid in TypeScript:
-			*         // static staticProperty;
-			*         // property;
-			*
-			*         constructor(p) { }
-			*         static staticMethod(p) { }
-			*         method(p) { }
-			*     }
-			*
-			*     // constructor
-			*     result = Reflect.getMetadata("custom:annotation", Example);
-			*
-			*     // property (on constructor)
-			*     result = Reflect.getMetadata("custom:annotation", Example, "staticProperty");
-			*
-			*     // property (on prototype)
-			*     result = Reflect.getMetadata("custom:annotation", Example.prototype, "property");
-			*
-			*     // method (on constructor)
-			*     result = Reflect.getMetadata("custom:annotation", Example, "staticMethod");
-			*
-			*     // method (on prototype)
-			*     result = Reflect.getMetadata("custom:annotation", Example.prototype, "method");
-			*
-			*/
-			function getMetadata(metadataKey, target, propertyKey) {
-				if (!IsObject(target)) throw new TypeError();
-				if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-				return OrdinaryGetMetadata(metadataKey, target, propertyKey);
-			}
-			exporter("getMetadata", getMetadata);
-			/**
-			* Gets the metadata value for the provided metadata key on the target object.
-			* @param metadataKey A key used to store and retrieve metadata.
-			* @param target The target object on which the metadata is defined.
-			* @param propertyKey (Optional) The property key for the target.
-			* @returns The metadata value for the metadata key if found; otherwise, `undefined`.
-			* @example
-			*
-			*     class Example {
-			*         // property declarations are not part of ES6, though they are valid in TypeScript:
-			*         // static staticProperty;
-			*         // property;
-			*
-			*         constructor(p) { }
-			*         static staticMethod(p) { }
-			*         method(p) { }
-			*     }
-			*
-			*     // constructor
-			*     result = Reflect.getOwnMetadata("custom:annotation", Example);
-			*
-			*     // property (on constructor)
-			*     result = Reflect.getOwnMetadata("custom:annotation", Example, "staticProperty");
-			*
-			*     // property (on prototype)
-			*     result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "property");
-			*
-			*     // method (on constructor)
-			*     result = Reflect.getOwnMetadata("custom:annotation", Example, "staticMethod");
-			*
-			*     // method (on prototype)
-			*     result = Reflect.getOwnMetadata("custom:annotation", Example.prototype, "method");
-			*
-			*/
-			function getOwnMetadata(metadataKey, target, propertyKey) {
-				if (!IsObject(target)) throw new TypeError();
-				if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-				return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
-			}
-			exporter("getOwnMetadata", getOwnMetadata);
-			/**
-			* Gets the metadata keys defined on the target object or its prototype chain.
-			* @param target The target object on which the metadata is defined.
-			* @param propertyKey (Optional) The property key for the target.
-			* @returns An array of unique metadata keys.
-			* @example
-			*
-			*     class Example {
-			*         // property declarations are not part of ES6, though they are valid in TypeScript:
-			*         // static staticProperty;
-			*         // property;
-			*
-			*         constructor(p) { }
-			*         static staticMethod(p) { }
-			*         method(p) { }
-			*     }
-			*
-			*     // constructor
-			*     result = Reflect.getMetadataKeys(Example);
-			*
-			*     // property (on constructor)
-			*     result = Reflect.getMetadataKeys(Example, "staticProperty");
-			*
-			*     // property (on prototype)
-			*     result = Reflect.getMetadataKeys(Example.prototype, "property");
-			*
-			*     // method (on constructor)
-			*     result = Reflect.getMetadataKeys(Example, "staticMethod");
-			*
-			*     // method (on prototype)
-			*     result = Reflect.getMetadataKeys(Example.prototype, "method");
-			*
-			*/
-			function getMetadataKeys(target, propertyKey) {
-				if (!IsObject(target)) throw new TypeError();
-				if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-				return OrdinaryMetadataKeys(target, propertyKey);
-			}
-			exporter("getMetadataKeys", getMetadataKeys);
-			/**
-			* Gets the unique metadata keys defined on the target object.
-			* @param target The target object on which the metadata is defined.
-			* @param propertyKey (Optional) The property key for the target.
-			* @returns An array of unique metadata keys.
-			* @example
-			*
-			*     class Example {
-			*         // property declarations are not part of ES6, though they are valid in TypeScript:
-			*         // static staticProperty;
-			*         // property;
-			*
-			*         constructor(p) { }
-			*         static staticMethod(p) { }
-			*         method(p) { }
-			*     }
-			*
-			*     // constructor
-			*     result = Reflect.getOwnMetadataKeys(Example);
-			*
-			*     // property (on constructor)
-			*     result = Reflect.getOwnMetadataKeys(Example, "staticProperty");
-			*
-			*     // property (on prototype)
-			*     result = Reflect.getOwnMetadataKeys(Example.prototype, "property");
-			*
-			*     // method (on constructor)
-			*     result = Reflect.getOwnMetadataKeys(Example, "staticMethod");
-			*
-			*     // method (on prototype)
-			*     result = Reflect.getOwnMetadataKeys(Example.prototype, "method");
-			*
-			*/
-			function getOwnMetadataKeys(target, propertyKey) {
-				if (!IsObject(target)) throw new TypeError();
-				if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-				return OrdinaryOwnMetadataKeys(target, propertyKey);
-			}
-			exporter("getOwnMetadataKeys", getOwnMetadataKeys);
-			/**
-			* Deletes the metadata entry from the target object with the provided key.
-			* @param metadataKey A key used to store and retrieve metadata.
-			* @param target The target object on which the metadata is defined.
-			* @param propertyKey (Optional) The property key for the target.
-			* @returns `true` if the metadata entry was found and deleted; otherwise, false.
-			* @example
-			*
-			*     class Example {
-			*         // property declarations are not part of ES6, though they are valid in TypeScript:
-			*         // static staticProperty;
-			*         // property;
-			*
-			*         constructor(p) { }
-			*         static staticMethod(p) { }
-			*         method(p) { }
-			*     }
-			*
-			*     // constructor
-			*     result = Reflect.deleteMetadata("custom:annotation", Example);
-			*
-			*     // property (on constructor)
-			*     result = Reflect.deleteMetadata("custom:annotation", Example, "staticProperty");
-			*
-			*     // property (on prototype)
-			*     result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "property");
-			*
-			*     // method (on constructor)
-			*     result = Reflect.deleteMetadata("custom:annotation", Example, "staticMethod");
-			*
-			*     // method (on prototype)
-			*     result = Reflect.deleteMetadata("custom:annotation", Example.prototype, "method");
-			*
-			*/
-			function deleteMetadata(metadataKey, target, propertyKey) {
-				if (!IsObject(target)) throw new TypeError();
-				if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-				if (!IsObject(target)) throw new TypeError();
-				if (!IsUndefined(propertyKey)) propertyKey = ToPropertyKey(propertyKey);
-				var provider = GetMetadataProvider(target, propertyKey, false);
-				if (IsUndefined(provider)) return false;
-				return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
-			}
-			exporter("deleteMetadata", deleteMetadata);
-			function DecorateConstructor(decorators, target) {
-				for (var i = decorators.length - 1; i >= 0; --i) {
-					var decorator = decorators[i];
-					var decorated = decorator(target);
-					if (!IsUndefined(decorated) && !IsNull(decorated)) {
-						if (!IsConstructor(decorated)) throw new TypeError();
-						target = decorated;
-					}
-				}
-				return target;
-			}
-			function DecorateProperty(decorators, target, propertyKey, descriptor) {
-				for (var i = decorators.length - 1; i >= 0; --i) {
-					var decorator = decorators[i];
-					var decorated = decorator(target, propertyKey, descriptor);
-					if (!IsUndefined(decorated) && !IsNull(decorated)) {
-						if (!IsObject(decorated)) throw new TypeError();
-						descriptor = decorated;
-					}
-				}
-				return descriptor;
-			}
-			function OrdinaryHasMetadata(MetadataKey, O, P) {
-				if (OrdinaryHasOwnMetadata(MetadataKey, O, P)) return true;
-				var parent = OrdinaryGetPrototypeOf(O);
-				if (!IsNull(parent)) return OrdinaryHasMetadata(MetadataKey, parent, P);
-				return false;
-			}
-			function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
-				var provider = GetMetadataProvider(O, P, false);
-				if (IsUndefined(provider)) return false;
-				return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
-			}
-			function OrdinaryGetMetadata(MetadataKey, O, P) {
-				if (OrdinaryHasOwnMetadata(MetadataKey, O, P)) return OrdinaryGetOwnMetadata(MetadataKey, O, P);
-				var parent = OrdinaryGetPrototypeOf(O);
-				if (!IsNull(parent)) return OrdinaryGetMetadata(MetadataKey, parent, P);
-			}
-			function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
-				var provider = GetMetadataProvider(O, P, false);
-				if (IsUndefined(provider)) return;
-				return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
-			}
-			function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
-				GetMetadataProvider(O, P, true).OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
-			}
-			function OrdinaryMetadataKeys(O, P) {
-				var ownKeys = OrdinaryOwnMetadataKeys(O, P);
-				var parent = OrdinaryGetPrototypeOf(O);
-				if (parent === null) return ownKeys;
-				var parentKeys = OrdinaryMetadataKeys(parent, P);
-				if (parentKeys.length <= 0) return ownKeys;
-				if (ownKeys.length <= 0) return parentKeys;
-				var set = new _Set();
-				var keys = [];
-				for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {
-					var key = ownKeys_1[_i];
-					var hasKey = set.has(key);
-					if (!hasKey) {
-						set.add(key);
-						keys.push(key);
-					}
-				}
-				for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {
-					var key = parentKeys_1[_a];
-					var hasKey = set.has(key);
-					if (!hasKey) {
-						set.add(key);
-						keys.push(key);
-					}
-				}
-				return keys;
-			}
-			function OrdinaryOwnMetadataKeys(O, P) {
-				var provider = GetMetadataProvider(O, P, false);
-				if (!provider) return [];
-				return provider.OrdinaryOwnMetadataKeys(O, P);
-			}
-			function Type(x) {
-				if (x === null) return 1;
-				switch (typeof x) {
-					case "undefined": return 0;
-					case "boolean": return 2;
-					case "string": return 3;
-					case "symbol": return 4;
-					case "number": return 5;
-					case "object": return x === null ? 1 : 6;
-					default: return 6;
-				}
-			}
-			function IsUndefined(x) {
-				return x === void 0;
-			}
-			function IsNull(x) {
-				return x === null;
-			}
-			function IsSymbol(x) {
-				return typeof x === "symbol";
-			}
-			function IsObject(x) {
-				return typeof x === "object" ? x !== null : typeof x === "function";
-			}
-			function ToPrimitive(input, PreferredType) {
-				switch (Type(input)) {
-					case 0: return input;
-					case 1: return input;
-					case 2: return input;
-					case 3: return input;
-					case 4: return input;
-					case 5: return input;
-				}
-				var hint = PreferredType === 3 ? "string" : PreferredType === 5 ? "number" : "default";
-				var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
-				if (exoticToPrim !== void 0) {
-					var result = exoticToPrim.call(input, hint);
-					if (IsObject(result)) throw new TypeError();
-					return result;
-				}
-				return OrdinaryToPrimitive(input, hint === "default" ? "number" : hint);
-			}
-			function OrdinaryToPrimitive(O, hint) {
-				if (hint === "string") {
-					var toString_1 = O.toString;
-					if (IsCallable(toString_1)) {
-						var result = toString_1.call(O);
-						if (!IsObject(result)) return result;
-					}
-					var valueOf = O.valueOf;
-					if (IsCallable(valueOf)) {
-						var result = valueOf.call(O);
-						if (!IsObject(result)) return result;
-					}
-				} else {
-					var valueOf = O.valueOf;
-					if (IsCallable(valueOf)) {
-						var result = valueOf.call(O);
-						if (!IsObject(result)) return result;
-					}
-					var toString_2 = O.toString;
-					if (IsCallable(toString_2)) {
-						var result = toString_2.call(O);
-						if (!IsObject(result)) return result;
-					}
-				}
-				throw new TypeError();
-			}
-			function ToBoolean(argument) {
-				return !!argument;
-			}
-			function ToString(argument) {
-				return "" + argument;
-			}
-			function ToPropertyKey(argument) {
-				var key = ToPrimitive(argument, 3);
-				if (IsSymbol(key)) return key;
-				return ToString(key);
-			}
-			function IsArray(argument) {
-				return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
-			}
-			function IsCallable(argument) {
-				return typeof argument === "function";
-			}
-			function IsConstructor(argument) {
-				return typeof argument === "function";
-			}
-			function IsPropertyKey(argument) {
-				switch (Type(argument)) {
-					case 3: return true;
-					case 4: return true;
-					default: return false;
-				}
-			}
-			function SameValueZero(x, y) {
-				return x === y || x !== x && y !== y;
-			}
-			function GetMethod(V, P) {
-				var func = V[P];
-				if (func === void 0 || func === null) return void 0;
-				if (!IsCallable(func)) throw new TypeError();
-				return func;
-			}
-			function GetIterator(obj) {
-				var method = GetMethod(obj, iteratorSymbol);
-				if (!IsCallable(method)) throw new TypeError();
-				var iterator = method.call(obj);
-				if (!IsObject(iterator)) throw new TypeError();
-				return iterator;
-			}
-			function IteratorValue(iterResult) {
-				return iterResult.value;
-			}
-			function IteratorStep(iterator) {
-				var result = iterator.next();
-				return result.done ? false : result;
-			}
-			function IteratorClose(iterator) {
-				var f = iterator["return"];
-				if (f) f.call(iterator);
-			}
-			function OrdinaryGetPrototypeOf(O) {
-				var proto = Object.getPrototypeOf(O);
-				if (typeof O !== "function" || O === functionPrototype) return proto;
-				if (proto !== functionPrototype) return proto;
-				var prototype = O.prototype;
-				var prototypeProto = prototype && Object.getPrototypeOf(prototype);
-				if (prototypeProto == null || prototypeProto === Object.prototype) return proto;
-				var constructor = prototypeProto.constructor;
-				if (typeof constructor !== "function") return proto;
-				if (constructor === O) return proto;
-				return constructor;
-			}
-			/**
-			* Creates a registry used to allow multiple `reflect-metadata` providers.
-			*/
-			function CreateMetadataRegistry() {
-				var fallback;
-				if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") fallback = CreateFallbackProvider(root.Reflect);
-				var first;
-				var second;
-				var rest;
-				var targetProviderMap = new _WeakMap();
-				var registry = {
-					registerProvider,
-					getProvider,
-					setProvider
-				};
-				return registry;
-				function registerProvider(provider) {
-					if (!Object.isExtensible(registry)) throw new Error("Cannot add provider to a frozen registry.");
-					switch (true) {
-						case fallback === provider: break;
-						case IsUndefined(first):
-							first = provider;
-							break;
-						case first === provider: break;
-						case IsUndefined(second):
-							second = provider;
-							break;
-						case second === provider: break;
-						default:
-							if (rest === void 0) rest = new _Set();
-							rest.add(provider);
-							break;
-					}
-				}
-				function getProviderNoCache(O, P) {
-					if (!IsUndefined(first)) {
-						if (first.isProviderFor(O, P)) return first;
-						if (!IsUndefined(second)) {
-							if (second.isProviderFor(O, P)) return first;
-							if (!IsUndefined(rest)) {
-								var iterator = GetIterator(rest);
-								while (true) {
-									var next = IteratorStep(iterator);
-									if (!next) return;
-									var provider = IteratorValue(next);
-									if (provider.isProviderFor(O, P)) {
-										IteratorClose(iterator);
-										return provider;
-									}
-								}
-							}
-						}
-					}
-					if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) return fallback;
-				}
-				function getProvider(O, P) {
-					var providerMap = targetProviderMap.get(O);
-					var provider;
-					if (!IsUndefined(providerMap)) provider = providerMap.get(P);
-					if (!IsUndefined(provider)) return provider;
-					provider = getProviderNoCache(O, P);
-					if (!IsUndefined(provider)) {
-						if (IsUndefined(providerMap)) {
-							providerMap = new _Map();
-							targetProviderMap.set(O, providerMap);
-						}
-						providerMap.set(P, provider);
-					}
-					return provider;
-				}
-				function hasProvider(provider) {
-					if (IsUndefined(provider)) throw new TypeError();
-					return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
-				}
-				function setProvider(O, P, provider) {
-					if (!hasProvider(provider)) throw new Error("Metadata provider not registered.");
-					var existingProvider = getProvider(O, P);
-					if (existingProvider !== provider) {
-						if (!IsUndefined(existingProvider)) return false;
-						var providerMap = targetProviderMap.get(O);
-						if (IsUndefined(providerMap)) {
-							providerMap = new _Map();
-							targetProviderMap.set(O, providerMap);
-						}
-						providerMap.set(P, provider);
-					}
-					return true;
-				}
-			}
-			/**
-			* Gets or creates the shared registry of metadata providers.
-			*/
-			function GetOrCreateMetadataRegistry() {
-				var metadataRegistry$1;
-				if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) metadataRegistry$1 = root.Reflect[registrySymbol];
-				if (IsUndefined(metadataRegistry$1)) metadataRegistry$1 = CreateMetadataRegistry();
-				if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) Object.defineProperty(root.Reflect, registrySymbol, {
-					enumerable: false,
-					configurable: false,
-					writable: false,
-					value: metadataRegistry$1
-				});
-				return metadataRegistry$1;
-			}
-			function CreateMetadataProvider(registry) {
-				var metadata$1 = new _WeakMap();
-				var provider = {
-					isProviderFor: function(O, P) {
-						var targetMetadata = metadata$1.get(O);
-						if (IsUndefined(targetMetadata)) return false;
-						return targetMetadata.has(P);
-					},
-					OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata$1,
-					OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata$1,
-					OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata$1,
-					OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys$1,
-					OrdinaryDeleteMetadata
-				};
-				metadataRegistry.registerProvider(provider);
-				return provider;
-				function GetOrCreateMetadataMap(O, P, Create) {
-					var targetMetadata = metadata$1.get(O);
-					var createdTargetMetadata = false;
-					if (IsUndefined(targetMetadata)) {
-						if (!Create) return void 0;
-						targetMetadata = new _Map();
-						metadata$1.set(O, targetMetadata);
-						createdTargetMetadata = true;
-					}
-					var metadataMap = targetMetadata.get(P);
-					if (IsUndefined(metadataMap)) {
-						if (!Create) return void 0;
-						metadataMap = new _Map();
-						targetMetadata.set(P, metadataMap);
-						if (!registry.setProvider(O, P, provider)) {
-							targetMetadata.delete(P);
-							if (createdTargetMetadata) metadata$1.delete(O);
-							throw new Error("Wrong provider for target.");
-						}
-					}
-					return metadataMap;
-				}
-				function OrdinaryHasOwnMetadata$1(MetadataKey, O, P) {
-					var metadataMap = GetOrCreateMetadataMap(O, P, false);
-					if (IsUndefined(metadataMap)) return false;
-					return ToBoolean(metadataMap.has(MetadataKey));
-				}
-				function OrdinaryGetOwnMetadata$1(MetadataKey, O, P) {
-					var metadataMap = GetOrCreateMetadataMap(O, P, false);
-					if (IsUndefined(metadataMap)) return void 0;
-					return metadataMap.get(MetadataKey);
-				}
-				function OrdinaryDefineOwnMetadata$1(MetadataKey, MetadataValue, O, P) {
-					GetOrCreateMetadataMap(O, P, true).set(MetadataKey, MetadataValue);
-				}
-				function OrdinaryOwnMetadataKeys$1(O, P) {
-					var keys = [];
-					var metadataMap = GetOrCreateMetadataMap(O, P, false);
-					if (IsUndefined(metadataMap)) return keys;
-					var iterator = GetIterator(metadataMap.keys());
-					var k = 0;
-					while (true) {
-						var next = IteratorStep(iterator);
-						if (!next) {
-							keys.length = k;
-							return keys;
-						}
-						var nextValue = IteratorValue(next);
-						try {
-							keys[k] = nextValue;
-						} catch (e) {
-							try {
-								IteratorClose(iterator);
-							} finally {
-								throw e;
-							}
-						}
-						k++;
-					}
-				}
-				function OrdinaryDeleteMetadata(MetadataKey, O, P) {
-					var metadataMap = GetOrCreateMetadataMap(O, P, false);
-					if (IsUndefined(metadataMap)) return false;
-					if (!metadataMap.delete(MetadataKey)) return false;
-					if (metadataMap.size === 0) {
-						var targetMetadata = metadata$1.get(O);
-						if (!IsUndefined(targetMetadata)) {
-							targetMetadata.delete(P);
-							if (targetMetadata.size === 0) metadata$1.delete(targetMetadata);
-						}
-					}
-					return true;
-				}
-			}
-			function CreateFallbackProvider(reflect) {
-				var defineMetadata$1 = reflect.defineMetadata, hasOwnMetadata$1 = reflect.hasOwnMetadata, getOwnMetadata$1 = reflect.getOwnMetadata, getOwnMetadataKeys$1 = reflect.getOwnMetadataKeys, deleteMetadata$1 = reflect.deleteMetadata;
-				var metadataOwner = new _WeakMap();
-				return {
-					isProviderFor: function(O, P) {
-						var metadataPropertySet = metadataOwner.get(O);
-						if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) return true;
-						if (getOwnMetadataKeys$1(O, P).length) {
-							if (IsUndefined(metadataPropertySet)) {
-								metadataPropertySet = new _Set();
-								metadataOwner.set(O, metadataPropertySet);
-							}
-							metadataPropertySet.add(P);
-							return true;
-						}
-						return false;
-					},
-					OrdinaryDefineOwnMetadata: defineMetadata$1,
-					OrdinaryHasOwnMetadata: hasOwnMetadata$1,
-					OrdinaryGetOwnMetadata: getOwnMetadata$1,
-					OrdinaryOwnMetadataKeys: getOwnMetadataKeys$1,
-					OrdinaryDeleteMetadata: deleteMetadata$1
-				};
-			}
-			/**
-			* Gets the metadata provider for an object. If the object has no metadata provider and this is for a create operation,
-			* then this module's metadata provider is assigned to the object.
-			*/
-			function GetMetadataProvider(O, P, Create) {
-				var registeredProvider = metadataRegistry.getProvider(O, P);
-				if (!IsUndefined(registeredProvider)) return registeredProvider;
-				if (Create) {
-					if (metadataRegistry.setProvider(O, P, metadataProvider)) return metadataProvider;
-					throw new Error("Illegal state.");
-				}
-			}
-			function CreateMapPolyfill() {
-				var cacheSentinel = {};
-				var arraySentinel = [];
-				var MapIterator = function() {
-					function MapIterator$1(keys, values, selector) {
-						this._index = 0;
-						this._keys = keys;
-						this._values = values;
-						this._selector = selector;
-					}
-					MapIterator$1.prototype["@@iterator"] = function() {
-						return this;
-					};
-					MapIterator$1.prototype[iteratorSymbol] = function() {
-						return this;
-					};
-					MapIterator$1.prototype.next = function() {
-						var index = this._index;
-						if (index >= 0 && index < this._keys.length) {
-							var result = this._selector(this._keys[index], this._values[index]);
-							if (index + 1 >= this._keys.length) {
-								this._index = -1;
-								this._keys = arraySentinel;
-								this._values = arraySentinel;
-							} else this._index++;
-							return {
-								value: result,
-								done: false
-							};
-						}
-						return {
-							value: void 0,
-							done: true
-						};
-					};
-					MapIterator$1.prototype.throw = function(error) {
-						if (this._index >= 0) {
-							this._index = -1;
-							this._keys = arraySentinel;
-							this._values = arraySentinel;
-						}
-						throw error;
-					};
-					MapIterator$1.prototype.return = function(value) {
-						if (this._index >= 0) {
-							this._index = -1;
-							this._keys = arraySentinel;
-							this._values = arraySentinel;
-						}
-						return {
-							value,
-							done: true
-						};
-					};
-					return MapIterator$1;
-				}();
-				return function() {
-					function Map$1() {
-						this._keys = [];
-						this._values = [];
-						this._cacheKey = cacheSentinel;
-						this._cacheIndex = -2;
-					}
-					Object.defineProperty(Map$1.prototype, "size", {
-						get: function() {
-							return this._keys.length;
-						},
-						enumerable: true,
-						configurable: true
-					});
-					Map$1.prototype.has = function(key) {
-						return this._find(key, false) >= 0;
-					};
-					Map$1.prototype.get = function(key) {
-						var index = this._find(key, false);
-						return index >= 0 ? this._values[index] : void 0;
-					};
-					Map$1.prototype.set = function(key, value) {
-						var index = this._find(key, true);
-						this._values[index] = value;
-						return this;
-					};
-					Map$1.prototype.delete = function(key) {
-						var index = this._find(key, false);
-						if (index >= 0) {
-							var size = this._keys.length;
-							for (var i = index + 1; i < size; i++) {
-								this._keys[i - 1] = this._keys[i];
-								this._values[i - 1] = this._values[i];
-							}
-							this._keys.length--;
-							this._values.length--;
-							if (SameValueZero(key, this._cacheKey)) {
-								this._cacheKey = cacheSentinel;
-								this._cacheIndex = -2;
-							}
-							return true;
-						}
-						return false;
-					};
-					Map$1.prototype.clear = function() {
-						this._keys.length = 0;
-						this._values.length = 0;
-						this._cacheKey = cacheSentinel;
-						this._cacheIndex = -2;
-					};
-					Map$1.prototype.keys = function() {
-						return new MapIterator(this._keys, this._values, getKey);
-					};
-					Map$1.prototype.values = function() {
-						return new MapIterator(this._keys, this._values, getValue);
-					};
-					Map$1.prototype.entries = function() {
-						return new MapIterator(this._keys, this._values, getEntry);
-					};
-					Map$1.prototype["@@iterator"] = function() {
-						return this.entries();
-					};
-					Map$1.prototype[iteratorSymbol] = function() {
-						return this.entries();
-					};
-					Map$1.prototype._find = function(key, insert) {
-						if (!SameValueZero(this._cacheKey, key)) {
-							this._cacheIndex = -1;
-							for (var i = 0; i < this._keys.length; i++) if (SameValueZero(this._keys[i], key)) {
-								this._cacheIndex = i;
-								break;
-							}
-						}
-						if (this._cacheIndex < 0 && insert) {
-							this._cacheIndex = this._keys.length;
-							this._keys.push(key);
-							this._values.push(void 0);
-						}
-						return this._cacheIndex;
-					};
-					return Map$1;
-				}();
-				function getKey(key, _) {
-					return key;
-				}
-				function getValue(_, value) {
-					return value;
-				}
-				function getEntry(key, value) {
-					return [key, value];
-				}
-			}
-			function CreateSetPolyfill() {
-				return function() {
-					function Set$1() {
-						this._map = new _Map();
-					}
-					Object.defineProperty(Set$1.prototype, "size", {
-						get: function() {
-							return this._map.size;
-						},
-						enumerable: true,
-						configurable: true
-					});
-					Set$1.prototype.has = function(value) {
-						return this._map.has(value);
-					};
-					Set$1.prototype.add = function(value) {
-						return this._map.set(value, value), this;
-					};
-					Set$1.prototype.delete = function(value) {
-						return this._map.delete(value);
-					};
-					Set$1.prototype.clear = function() {
-						this._map.clear();
-					};
-					Set$1.prototype.keys = function() {
-						return this._map.keys();
-					};
-					Set$1.prototype.values = function() {
-						return this._map.keys();
-					};
-					Set$1.prototype.entries = function() {
-						return this._map.entries();
-					};
-					Set$1.prototype["@@iterator"] = function() {
-						return this.keys();
-					};
-					Set$1.prototype[iteratorSymbol] = function() {
-						return this.keys();
-					};
-					return Set$1;
-				}();
-			}
-			function CreateWeakMapPolyfill() {
-				var UUID_SIZE = 16;
-				var keys = HashMap.create();
-				var rootKey = CreateUniqueKey();
-				return function() {
-					function WeakMap$1() {
-						this._key = CreateUniqueKey();
-					}
-					WeakMap$1.prototype.has = function(target) {
-						var table = GetOrCreateWeakMapTable(target, false);
-						return table !== void 0 ? HashMap.has(table, this._key) : false;
-					};
-					WeakMap$1.prototype.get = function(target) {
-						var table = GetOrCreateWeakMapTable(target, false);
-						return table !== void 0 ? HashMap.get(table, this._key) : void 0;
-					};
-					WeakMap$1.prototype.set = function(target, value) {
-						var table = GetOrCreateWeakMapTable(target, true);
-						table[this._key] = value;
-						return this;
-					};
-					WeakMap$1.prototype.delete = function(target) {
-						var table = GetOrCreateWeakMapTable(target, false);
-						return table !== void 0 ? delete table[this._key] : false;
-					};
-					WeakMap$1.prototype.clear = function() {
-						this._key = CreateUniqueKey();
-					};
-					return WeakMap$1;
-				}();
-				function CreateUniqueKey() {
-					var key;
-					do
-						key = "@@WeakMap@@" + CreateUUID();
-					while (HashMap.has(keys, key));
-					keys[key] = true;
-					return key;
-				}
-				function GetOrCreateWeakMapTable(target, create) {
-					if (!hasOwn.call(target, rootKey)) {
-						if (!create) return void 0;
-						Object.defineProperty(target, rootKey, { value: HashMap.create() });
-					}
-					return target[rootKey];
-				}
-				function FillRandomBytes(buffer, size) {
-					for (var i = 0; i < size; ++i) buffer[i] = Math.random() * 255 | 0;
-					return buffer;
-				}
-				function GenRandomBytes(size) {
-					if (typeof Uint8Array === "function") {
-						var array = new Uint8Array(size);
-						if (typeof crypto !== "undefined") crypto.getRandomValues(array);
-						else if (typeof msCrypto !== "undefined") msCrypto.getRandomValues(array);
-						else FillRandomBytes(array, size);
-						return array;
-					}
-					return FillRandomBytes(new Array(size), size);
-				}
-				function CreateUUID() {
-					var data = GenRandomBytes(UUID_SIZE);
-					data[6] = data[6] & 79 | 64;
-					data[8] = data[8] & 191 | 128;
-					var result = "";
-					for (var offset = 0; offset < UUID_SIZE; ++offset) {
-						var byte = data[offset];
-						if (offset === 4 || offset === 6 || offset === 8) result += "-";
-						if (byte < 16) result += "0";
-						result += byte.toString(16).toLowerCase();
-					}
-					return result;
-				}
-			}
-			function MakeDictionary(obj) {
-				obj.__ = void 0;
-				delete obj.__;
-				return obj;
-			}
-		});
-	})(Reflect || (Reflect = {}));
-}));
-
-//#endregion
-//#region src/decorators/params.utils.ts
-var import_Reflect = require_Reflect();
-const createTemporalParamDecorator = (paramtype) => {
-	return (data) => (target, key, index) => {
-		const args = Reflect.getMetadata(TEMPORAL_ARGS_METADATA, target, key) || {};
-		args[index] = {
-			index,
-			data,
-			type: paramtype
-		};
-		Reflect.defineMetadata(TEMPORAL_ARGS_METADATA, args, target, key);
-	};
-};
-
 //#endregion
 //#region src/decorators/payload.decorator.ts
-function Payload(property) {
-	return createTemporalParamDecorator(TemporalParamType.PAYLOAD)(property);
-}
-
-//#endregion
-//#region src/decorators/context.decorator.ts
-function Context() {
-	return createTemporalParamDecorator(TemporalParamType.CONTEXT)();
-}
+const ActivityPayload = () => (0, _nestjs_common.createParamDecorator)((_, ctx) => {
+	return ctx.getArgByIndex(0);
+});
 
 //#endregion
 exports.Activities = Activities;
 exports.Activity = Activity;
-exports.Context = Context;
+exports.ActivityPayload = ActivityPayload;
 exports.InjectTemporalClient = InjectTemporalClient;
-exports.Payload = Payload;
 exports.TemporalExecutionContext = TemporalExecutionContext;
 Object.defineProperty(exports, 'TemporalExplorer', {
   enumerable: true,