@globalart/nestjs-temporal 1.0.1 → 1.0.2

package/dist/index.cjs

@@ -1,5 +1,10 @@
+//#region rolldown:runtime
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+//#endregion
 let _nestjs_common = require("@nestjs/common");
 let _nestjs_core = require("@nestjs/core");
+let rxjs = require("rxjs");
 let _temporalio_worker = require("@temporalio/worker");
 let _temporalio_client = require("@temporalio/client");
 let _nestjs_common_constants = require("@nestjs/common/constants");
@@ -9,6 +14,7 @@ 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";
 
 //#endregion
 //#region \0@oxc-project+runtime@0.107.0/helpers/decorateMetadata.js
@@ -67,18 +73,77 @@ TemporalMetadataAccessor = __decorate([(0, _nestjs_common.Injectable)(), __decor
 //#region src/temporal.module-definition.ts
 const { ConfigurableModuleClass, MODULE_OPTIONS_TOKEN: TEMPORAL_MODULE_OPTIONS_TOKEN, OPTIONS_TYPE: TEMPORAL_MODULE_OPTIONS_TYPE, ASYNC_OPTIONS_TYPE: TEMPORAL_MODULE_ASYNC_OPTIONS_TYPE } = new _nestjs_common.ConfigurableModuleBuilder().setClassMethodName("registerWorker").build();
 
+//#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;
+}({});
+
+//#endregion
+//#region src/activity-execution-context.ts
+var ActivityExecutionContext = class {
+	constructor(instance, handler, args) {
+		this.instance = instance;
+		this.handler = handler;
+		this.args = args;
+	}
+	getClass() {
+		return this.instance.constructor;
+	}
+	getHandler() {
+		return this.handler;
+	}
+	getArgs() {
+		return this.args;
+	}
+	getArgByIndex(index) {
+		return this.args[index];
+	}
+	switchToRpc() {
+		throw new Error("Context does not support RPC context");
+	}
+	switchToHttp() {
+		throw new Error("Context does not support HTTP context");
+	}
+	switchToWs() {
+		throw new Error("Context does not support WebSocket context");
+	}
+	getType() {
+		return "temporal";
+	}
+};
+
+//#endregion
+//#region src/temporal-params.factory.ts
+var TemporalParamsFactory = class {
+	constructor(instance, handler) {
+		this.instance = instance;
+		this.handler = handler;
+	}
+	exchangeKeyForValue(type, data, args) {
+		switch (type) {
+			case TemporalParamType.PAYLOAD: return data && args[0] && typeof args[0] === "object" ? args[0][data] : args[0];
+			case TemporalParamType.CONTEXT: return new ActivityExecutionContext(this.instance, this.handler, args);
+			default: return null;
+		}
+	}
+};
+
 //#endregion
 //#region src/temporal.explorer.ts
-var _ref, _ref2, _ref3, _TemporalExplorer;
+var _ref, _ref2, _ref3, _ref4, _TemporalExplorer;
 let TemporalExplorer = _TemporalExplorer = class TemporalExplorer$1 {
 	options;
 	logger = new _nestjs_common.Logger(_TemporalExplorer.name);
 	worker;
 	workerRunPromise;
-	constructor(discoveryService, metadataAccessor, metadataScanner) {
+	constructor(discoveryService, metadataAccessor, metadataScanner, externalContextCreator) {
 		this.discoveryService = discoveryService;
 		this.metadataAccessor = metadataAccessor;
 		this.metadataScanner = metadataScanner;
+		this.externalContextCreator = externalContextCreator;
 	}
 	/**
 	* Initializes the module by exploring and setting up the Temporal worker.
@@ -195,7 +260,13 @@ let TemporalExplorer = _TemporalExplorer = class TemporalExplorer$1 {
 			this.metadataScanner.scanFromPrototype(instance, Object.getPrototypeOf(instance), (key) => {
 				if (this.metadataAccessor.isActivity(instance[key])) {
 					if (isRequestScoped) this.logger.warn(`Request-scoped activities are not yet fully supported. Activity "${key}" from class "${instance.constructor.name}" may not work correctly.`);
-					activitiesMethod[key] = instance[key].bind(instance);
+					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);
+						return (0, rxjs.isObservable)(result) ? await (0, rxjs.lastValueFrom)(result) : await result;
+					};
 				}
 			});
 		});
@@ -206,7 +277,8 @@ __decorate([(0, _nestjs_common.Inject)(TEMPORAL_MODULE_OPTIONS_TOKEN), __decorat
 TemporalExplorer = _TemporalExplorer = __decorate([(0, _nestjs_common.Injectable)(), __decorateMetadata("design:paramtypes", [
 	typeof (_ref = typeof _nestjs_core.DiscoveryService !== "undefined" && _nestjs_core.DiscoveryService) === "function" ? _ref : Object,
 	typeof (_ref2 = typeof TemporalMetadataAccessor !== "undefined" && TemporalMetadataAccessor) === "function" ? _ref2 : Object,
-	typeof (_ref3 = typeof _nestjs_core.MetadataScanner !== "undefined" && _nestjs_core.MetadataScanner) === "function" ? _ref3 : Object
+	typeof (_ref3 = typeof _nestjs_core.MetadataScanner !== "undefined" && _nestjs_core.MetadataScanner) === "function" ? _ref3 : Object,
+	typeof (_ref4 = typeof _nestjs_core.ExternalContextCreator !== "undefined" && _nestjs_core.ExternalContextCreator) === "function" ? _ref4 : Object
 ])], TemporalExplorer);
 
 //#endregion
@@ -321,22 +393,6 @@ let TemporalModule = _TemporalModule = class TemporalModule$1 extends Configurab
 };
 TemporalModule = _TemporalModule = __decorate([(0, _nestjs_common.Module)({})], TemporalModule);
 
-//#endregion
-//#region src/decorators/workflows.decorator.ts
-function Workflows(nameOrOptions) {
-	const options = nameOrOptions && typeof nameOrOptions === "object" ? nameOrOptions : { name: nameOrOptions };
-	return (target) => {
-		(0, _nestjs_common.SetMetadata)(_nestjs_common_constants.SCOPE_OPTIONS_METADATA, options)(target);
-		(0, _nestjs_common.SetMetadata)(TEMPORAL_MODULE_WORKFLOW, options)(target);
-	};
-}
-
-//#endregion
-//#region src/decorators/workflow.decorator.ts
-function WorkflowMethod(nameOrOptions) {
-	return (0, _nestjs_common.SetMetadata)(TEMPORAL_MODULE_WORKFLOW_METHOD, (nameOrOptions && typeof nameOrOptions === "object" ? nameOrOptions : { name: nameOrOptions }) || {});
-}
-
 //#endregion
 //#region src/decorators/activities.decorator.ts
 function Activities(queueNameOrOptions) {
@@ -369,10 +425,1282 @@ function Activity(nameOrOptions) {
 */
 const InjectTemporalClient = (name) => (0, _nestjs_common.Inject)(getQueueToken(name));
 
+//#endregion
+//#region src/decorators/workflow.decorator.ts
+function WorkflowMethod(nameOrOptions) {
+	return (0, _nestjs_common.SetMetadata)(TEMPORAL_MODULE_WORKFLOW_METHOD, (nameOrOptions && typeof nameOrOptions === "object" ? nameOrOptions : { name: nameOrOptions }) || {});
+}
+
+//#endregion
+//#region src/decorators/workflows.decorator.ts
+function Workflows(nameOrOptions) {
+	const options = nameOrOptions && typeof nameOrOptions === "object" ? nameOrOptions : { name: nameOrOptions };
+	return (target) => {
+		(0, _nestjs_common.SetMetadata)(_nestjs_common_constants.SCOPE_OPTIONS_METADATA, options)(target);
+		(0, _nestjs_common.SetMetadata)(TEMPORAL_MODULE_WORKFLOW, options)(target);
+	};
+}
+
+//#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)();
+}
+
 //#endregion
 exports.Activities = Activities;
 exports.Activity = Activity;
+exports.ActivityExecutionContext = ActivityExecutionContext;
+exports.Context = Context;
 exports.InjectTemporalClient = InjectTemporalClient;
+exports.Payload = Payload;
 Object.defineProperty(exports, 'TemporalExplorer', {
   enumerable: true,
   get: function () {