@herrromich/az-functions 1.0.0

package/dist/index.cjs.LICENSE.txt

@@ -0,0 +1,24 @@
+/*!
+ * mime-db
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015-2022 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * mime-types
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+/**
+ * @license
+ * Lodash <https://lodash.com/>
+ * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */

package/dist/src/context/index.d.ts

@@ -0,0 +1,4 @@
+export * from './platform-context.manager';
+export * from './platform-context.model';
+export * from './platform-context.provider';
+export * from './platform.execution.context';

package/dist/src/context/platform-context.manager.d.ts

@@ -0,0 +1,23 @@
+import { PlatformContext } from './platform-context.model';
+/**
+ * A unique identifier for the PlatformContextManager service.
+ * This identifier can be used for dependency injection and service resolution.
+ */
+export declare const PLATFORM_CONTEXT_MANAGER: import("inversify").ServiceIdentifier<PlatformContextManager>;
+/**
+ * Interface representing a manager for PlatformContext instances.
+ * The manager provides methods to access the active context and to run code within a specific context.
+ *
+ * - `active()`: Returns the currently active PlatformContext, or undefined if no context is active.
+ * - `runWith(platformContext, callback)`: Runs the provided callback function within the specified PlatformContext.
+ *   The callback will have access to the context during its execution.
+ */
+export interface PlatformContextManager {
+    active(): PlatformContext | undefined;
+    runWith<T>(platformContext: PlatformContext, callback: () => T): T;
+}
+export declare class BasePlatformContextManager implements PlatformContextManager {
+    private readonly storage;
+    runWith<T>(platformContext: PlatformContext, callback: () => T): T;
+    active(): PlatformContext | undefined;
+}

package/dist/src/context/platform-context.model.d.ts

@@ -0,0 +1,56 @@
+import { InvocationContext } from '@azure/functions';
+import { AzFunctionsRuntimeError } from '../shared';
+/**
+ * Error class representing errors related to the platform context in Azure Functions.
+ * This class extends the AzFunctionsRuntimeError and can be used to throw errors specific to platform context operations.
+ */
+export declare class PlatformContextError extends AzFunctionsRuntimeError {
+}
+/**
+ * Type representing a unique key for storing and retrieving values in the PlatformContext.
+ * The key is created using a symbol, ensuring uniqueness across the application.
+ * The generic type parameter T allows for type safety when associating values with the key.
+ *
+ * @template T - The type of the value associated with the key.
+ */
+export type PlatformContextValueKey<T = unknown> = symbol & {
+    __type: T;
+};
+/**
+ * Creates a unique key for storing and retrieving values in the PlatformContext.
+ * The key is created using a symbol, ensuring uniqueness across the application.
+ *
+ * @template T - The type of the value associated with the key.
+ * @param key - The unique string identifier for the key.
+ * @returns A unique PlatformContextValueKey for the specified type.
+ *
+ * @example
+ * const MY_KEY = createPlatformContextValueKey<MyType>('MyUniqueKey');
+ *
+ * // Retrieve a value from the PlatformContext using the key
+ * const value = platformContext.getValue(MY_KEY);
+ *
+ * // Set a value in the PlatformContext using the key
+ * platformContext.setValue(MY_KEY, myValue);
+ *
+ * // Delete a value from the PlatformContext using the key
+ * platformContext.deleteValue(MY_KEY);
+ */
+export declare function createPlatformContextValueKey<T>(key: string): PlatformContextValueKey<T>;
+/**
+ * Interface representing the platform context in Azure Functions.
+ * The PlatformContext provides access to the invocation context and allows storing and retrieving values associated with the context.
+ *
+ * - `invocationContext`: The InvocationContext associated with the current execution.
+ * - `getValue(key)`: Retrieves a value associated with the specified key from the context.
+ * - `setValue(key, value)`: Sets a value associated with the specified key in the context.
+ * - `deleteValue(key)`: Deletes a value associated with the specified key from the context.
+ * - `clone()`: Creates a deep copy of the current PlatformContext, preserving its values and invocation context.
+ */
+export interface PlatformContext {
+    readonly invocationContext: InvocationContext;
+    getValue<T>(key: PlatformContextValueKey<T>): T | undefined;
+    setValue<T>(key: PlatformContextValueKey<T>, value: T): PlatformContext;
+    deleteValue(key: PlatformContextValueKey): PlatformContext;
+    clone(): PlatformContext;
+}

package/dist/src/context/platform-context.provider.d.ts

@@ -0,0 +1,23 @@
+import { InvocationContext } from '@azure/functions';
+import * as winston from 'winston';
+import { PlatformContext } from './platform-context.model';
+/**
+ * A unique identifier for the PlatformContextProvider service.
+ * This identifier can be used for dependency injection and service resolution.
+ */
+export declare const PLATFORM_CONTEXT_PROVIDER: import("inversify").ServiceIdentifier<PlatformContextProvider>;
+/**
+ * Interface representing a provider for PlatformContext instances.
+ * The provider is responsible for creating and providing PlatformContext instances based on the given InvocationContext.
+ *
+ * - `providePlatformContext(invocationContext)`: Creates and returns a PlatformContext instance for the provided InvocationContext.
+ */
+export interface PlatformContextProvider {
+    providePlatformContext(invocationContext: InvocationContext): PlatformContext;
+}
+export declare const ORIGINAL_INVOCATION_CONTEXT_VALUE_KEY: import("./platform-context.model").PlatformContextValueKey<InvocationContext>;
+export declare class PlatformExecutionContextProvider implements PlatformContextProvider {
+    private readonly logger;
+    constructor(logger: winston.Logger);
+    providePlatformContext(invocationContext: InvocationContext): PlatformContext;
+}

package/dist/src/context/platform.execution.context.d.ts

@@ -0,0 +1,13 @@
+import { InvocationContext } from '@azure/functions';
+import * as winston from 'winston';
+import { PlatformContext, PlatformContextValueKey } from './platform-context.model';
+export declare class PlatformExecutionContext implements PlatformContext {
+    private readonly data;
+    readonly invocationContext: InvocationContext;
+    private readonly logger;
+    constructor(invocationContext: InvocationContext, logger: winston.Logger);
+    getValue<T>(key: PlatformContextValueKey<T>): T | undefined;
+    setValue<T>(key: PlatformContextValueKey<T>, value: T): PlatformContext;
+    deleteValue(key: PlatformContextValueKey): PlatformContext;
+    clone(): PlatformContext;
+}

package/dist/src/context/wrapped-invocation-context.d.ts

@@ -0,0 +1,5 @@
+import { InvocationContext } from '@azure/functions';
+import * as winston from 'winston';
+export declare class WrappedInvocationContext extends InvocationContext {
+    constructor(parentInvocationContext: InvocationContext, logger: winston.Logger);
+}

package/dist/src/event-hub-handler/decorators/decorators.d.ts

@@ -0,0 +1,161 @@
+import { EventHubHandlerConfig, EventHubTriggerMessageArgConfig, OnEventHubTriggerConfig } from './decorators.model';
+/**
+ * Class decorator to define an Event Hub function handler.
+ * This decorator registers the class as an Event Hub handler with the specified configuration.
+ *
+ * @param config Configuration for the Event Hub handler, including the name and event hub details.
+ *
+ * @example
+ * ```ts
+ * @EventHubHandler({
+ *   eventHubName: 'my-event-hub',
+ *   connection: 'EventHubConnectionString',
+ *   consumerGroup: '$Default',
+ * })
+ * class MyEventHubHandler implements OnEventHubTrigger {
+ *
+ *   @OnEventHubTrigger({ cardinality: 'many' })
+ *   async handle(
+ *     @Messages({ withPayload: z.object({ id: z.string(), value: z.number() }) }) messages: EventHubMessageWrapper<{ id: string; value: number }>[],
+ *     InvocationCtx: InvocationContext
+ *   ): Promise<void> {
+ *     for (const message of messages) {
+ *       console.log(`Received Message with id: ${message.payload.id} and value: ${message.payload.value}`);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare function EventHubHandler(config: EventHubHandlerConfig): ClassDecorator;
+/**
+ * Class decorator to define an Event Hub function handler.
+ * This decorator registers the class as an Event Hub handler with the specified configuration.
+ *
+ * @param config Configuration for the Event Hub handler, including the name and event hub details.
+ *
+ * @example
+ * ```ts
+ * const eventPayloadSchema = z.object({ id: z.string(), value: z.number() });
+ * type EventPayload = z.infer<typeof eventPayloadSchema>;
+ *
+ * @EventHubHandler({
+ *   eventHubName: 'my-event-hub',
+ *   connection: 'EventHubConnectionString',
+ *   consumerGroup: '$Default',
+ * })
+ * class MyEventHubHandler {
+ *   @OnEventHubTrigger({
+ *     triggerId: 'my-event-hub-trigger',
+ *     cardinality: 'many'
+ *   })
+ *   async handle(
+ *     @Messages({ withPayload: eventPayloadSchema, withEventData: true }) messages: EventHubMessageWrapper<EventPayload, undefined, undefined, true>[],
+ *     InvocationCtx: InvocationContext
+ *   ): Promise<void> {
+ *     for (const message of messages) {
+ *       console.log(`Received Message with id: ${message.payload.id} and value: ${message.payload.value}, enqueued at: ${message.eventData.enqueuedTimeUtc}`);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare function OnEventHubTrigger(config: OnEventHubTriggerConfig): MethodDecorator;
+/**
+ * Parameter decorator to inject Event Hub Message data into the handler method.
+ *
+ * This decorator can be used to specify the structure of the Event Hub Message payload,
+ * system properties, and custom properties using Zod schemas.
+ *
+ * @param messageConfig
+ * Configuration for the Event Hub Message argument, including optional Zod schemas for payload, system properties, and custom properties.
+ * - `withPayload`: A Zod schema to validate and parse the Message payload.
+ * - `withSystemProperties`: A Zod schema to validate and parse the system properties of the Message. If not provided, system properties will not be included.
+ * - `withProperties`: A Zod schema to validate and parse custom properties of the Message. If not provided, custom properties will not be included.
+ * - `withEventData`: If set to true, includes the raw Event Hub event data in the argument.
+ *
+ * @example
+ * ```ts
+ * const eventPayloadSchema = z.object({ id: z.string(), value: z.number() });
+ * type EventPayload = z.infer<typeof eventPayloadSchema>;
+ *
+ * const eventAppPropertiesSchema = z.object({ APP_REGISTRATION_ID: z.string() });
+ * type EventAppProperties = z.infer<typeof eventAppPropertiesSchema>;
+ *
+ * class MyEventHubHandler implements OnEventHubTrigger {
+ *  async handle(
+ *     @Message({ withPayload: eventPayloadSchema, withProperties: eventAppPropertiesSchema
+ *     }) Message: EventHubMessageWrapper<EventPayload, undefined, EventAppProperties>,
+ *     @InvocationCtx() context: InvocationContext
+ *   ): Promise<void> {
+ *     context.log(`Received Message with id: ${Message.payload.id} and value: ${Message.payload.value}`);
+ *   }
+ * }
+ * ```
+ */
+export declare function Message(messageConfig: EventHubTriggerMessageArgConfig): ParameterDecorator;
+/**
+ * Parameter decorator to inject multiple Event Hub Messages into the handler method.
+ *
+ * This decorator can be used to specify the structure of the Event Hub Message payload,
+ * system properties, and custom properties using Zod schemas.
+ * @param messagesConfig
+ * Configuration for the Event Hub Messages argument, including optional Zod schemas for payload, system properties, and custom properties.
+ * - `withPayload`: A Zod schema to validate and parse the Message payload.
+ * - `withSystemProperties`: A Zod schema to validate and parse the system properties of the Message. If not provided, system properties will not be included.
+ * - `withProperties`: A Zod schema to validate and parse custom properties of the Message. If not provided, custom properties will not be included.
+ * - `withEventData`: If set to true, includes the raw Event Hub event data in the argument.
+ *
+ * @example
+ * ```ts
+const eventPayloadSchema = z.object({ id: z.string(), value: z.number() });
+type EventPayload = z.infer<typeof eventPayloadSchema>;
+
+ * class MyEventHubHandler implements OnEventHubTrigger {
+ *  async handle(
+ *     @Messages({ withPayload: eventPayloadSchema }) messages: EventHubMessageWrapper<EventPayload>[],
+ *     @InvocationCtx() context: InvocationContext
+ *   ): Promise<void> {
+ *   for (const message of messages) {
+ *    context.log(`Received Message with id: ${message.payload.id} and value: ${message.payload.value}`);
+ *   }
+ *  }
+ * }
+ * ```
+ */
+export declare function Messages(messagesConfig: EventHubTriggerMessageArgConfig): ParameterDecorator;
+/**
+ * Parameter decorator to inject the raw Event Hub Message into the handler method.
+ * This decorator can be used when you need access to the complete Event Hub Message object,
+ *
+ * @example
+ * ```ts
+ * class MyEventHubHandler implements OnEventHubTrigger {
+ *  async handle(
+ *     @RawMessage() message: unknown,
+ *     @InvocationCtx() context: InvocationContext
+ *   ): Promise<void> {
+ *     context.log(`Received raw Message: ${JSON.stringify(message)}`);
+ *   }
+ * }
+ * ```
+ */
+export declare function RawMessage(): ParameterDecorator;
+/**
+ * Parameter decorator to inject multiple raw Event Hub Messages into the handler method.
+ * This decorator can be used when you need access to the complete Event Hub Message objects,
+ *
+ * @example
+ * ```ts
+ * class MyEventHubHandler implements OnEventHubTrigger {
+ *  async handle(
+ *     @RawMessages() messages: unknown[],
+ *     @InvocationCtx() context: InvocationContext
+ *   ): Promise<void> {
+ *     for (const message of messages) {
+ *       context.log(`Received raw Message: ${JSON.stringify(message)}`);
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare function RawMessages(): ParameterDecorator;

package/dist/src/event-hub-handler/decorators/decorators.model.d.ts

@@ -0,0 +1,62 @@
+import { EventHubFunctionOptions, EventHubTriggerOptions } from '@azure/functions';
+import { ArgMetadata, CommonArgMetadata, TriggerHandlerClassMetadata } from '../../shared';
+import { ZodType } from 'zod';
+/**
+ * Configuration for an Event Hub handler.
+ * - `connection`: The name of the app setting that contains the Event Hub connection string.
+ * - `eventHubName`: The name of the Event Hub to listen to.
+ */
+export interface EventHubHandlerConfig {
+    connection: string;
+    eventHubName: string;
+}
+export declare const EVENT_HUB_HANDLER_TYPE = "event-hub-handler";
+export interface EventHubHandlerMetadata extends TriggerHandlerClassMetadata, EventHubHandlerConfig {
+    type: typeof EVENT_HUB_HANDLER_TYPE;
+}
+export type EventHubHandlerCardinality = EventHubTriggerOptions['cardinality'];
+/**
+ * Configuration for an Event Hub handler.
+ * - `triggerId`: A unique identifier for the trigger.
+ * - `consumerGroup`: (Optional) The consumer group to use. Defaults to `$Default`.
+ * - `cardinality`: (Optional) The cardinality of the Messages, either 'one' or 'many'. Defaults to 'many'.
+ * - `extraInputs`: (Optional) Additional inputs for the function.
+ * - `extraOutputs`: (Optional) Additional outputs for the function.
+ */
+export type OnEventHubTriggerConfig = {
+    triggerId?: string;
+    consumerGroup?: string;
+    cardinality?: EventHubHandlerCardinality;
+} & Pick<EventHubFunctionOptions, 'extraInputs' | 'extraOutputs'>;
+/**
+ * Configuration for an Event Hub trigger message argument.
+ * - `withPayload`: (Optional) A Zod schema for the payload of the message. If not provided, the payload will be of type `unknown`.
+ * - `withSystemProperties`: (Optional) A Zod schema for the system properties of the message. If not provided, the system properties won't be included in the message argument.
+ * - `withProperties`: (Optional) A Zod schema for the custom properties of the message. If not provided, the properties won't be included in the message argument.
+ * - `withEventData`: (Optional) If true, includes the raw EventData in the message argument.
+ */
+export interface EventHubTriggerMessageArgConfig {
+    withPayload?: ZodType<unknown>;
+    withSystemProperties?: ZodType<unknown>;
+    withProperties?: ZodType<unknown>;
+    withEventData?: true;
+}
+export interface EventHubHandlerMessageArgMetadata {
+    payloadSchema?: ZodType<unknown>;
+    systemPropertiesSchema?: ZodType<unknown>;
+    propertiesSchema?: ZodType<unknown>;
+    isEventData?: true;
+}
+export interface EventHubHandlerDataArgMetadata extends EventHubHandlerMessageArgMetadata, ArgMetadata {
+    type: 'message' | 'messages';
+}
+export interface EventHubHandlerRawDataArgMetadata extends ArgMetadata {
+    type: 'rawMessage' | 'rawMessages';
+}
+export type EventHubHandlerArgMetadata = CommonArgMetadata | EventHubHandlerRawDataArgMetadata | EventHubHandlerDataArgMetadata;
+export interface OnEventHubTriggerArgsMetadata {
+    args: EventHubHandlerArgMetadata[];
+}
+export type EventHubTriggerMetadata = {
+    type: typeof EVENT_HUB_HANDLER_TYPE;
+} & OnEventHubTriggerConfig & OnEventHubTriggerArgsMetadata;

package/dist/src/event-hub-handler/decorators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './decorators';
+export * from './decorators.model';

package/dist/src/event-hub-handler/event-hub-handler-metadata.reader.d.ts

@@ -0,0 +1,8 @@
+import { TriggerHandlerClass, TriggerHandlerMetadataReader } from '../shared';
+import { EventHubHandlerMetadata, EventHubTriggerMetadata } from './decorators';
+export declare class EventHubHandlerMetadataReader {
+    private readonly metadataReader;
+    constructor(metadataReader: TriggerHandlerMetadataReader);
+    getHandlerClassMetadata(azureFunction: TriggerHandlerClass): EventHubHandlerMetadata;
+    getTriggerMetadata(azureFunction: TriggerHandlerClass, operation: string): EventHubTriggerMetadata;
+}

package/dist/src/event-hub-handler/event-hub-handler-registration.service.d.ts

@@ -0,0 +1,12 @@
+import { Container } from 'inversify';
+import { TriggerHandlerClass, TriggerHandlerRegistrationService } from '../shared';
+import { EventHubHandlerFactory } from './event-hub-handler.factory';
+import { EventHubTriggersRegistrationService } from './event-hub-triggers-registration.service';
+export declare class EventHubHandlerRegistrationService implements TriggerHandlerRegistrationService {
+    private readonly platformContainer;
+    private readonly eventHubHandlerProvider;
+    private readonly triggersRegistrationService;
+    constructor(platformContainer: Container, eventHubHandlerProvider: EventHubHandlerFactory, triggersRegistrationService: EventHubTriggersRegistrationService);
+    register(eventHubHandlerClass: TriggerHandlerClass): void;
+    private registerTrigger;
+}

package/dist/src/event-hub-handler/event-hub-handler.factory.d.ts

@@ -0,0 +1,13 @@
+import { InvocationContext } from '@azure/functions';
+import { Container } from 'inversify';
+import { LoggerFactory } from '../logger';
+import { EventHubTriggerSupportFactory } from './event-hub-trigger-support.factory';
+import { EventhubTriggerRegistration } from './event-hub-triggers-registration.service';
+export type EventHubTriggerHandler = (messages: unknown, invocationContext: InvocationContext) => Promise<void>;
+export declare class EventHubHandlerFactory {
+    private readonly platformContainer;
+    private readonly eventHubTriggerService;
+    private readonly logger;
+    constructor(loggerFactory: LoggerFactory, platformContainer: Container, eventHubTriggerService: EventHubTriggerSupportFactory);
+    createHandler(registrationData: EventhubTriggerRegistration, method: (...args: unknown[]) => Promise<unknown>): EventHubTriggerHandler;
+}

package/dist/src/event-hub-handler/event-hub-handler.model.d.ts

@@ -0,0 +1,101 @@
+import { InvocationContext } from '@azure/functions';
+import { AzFunctionsSystemError } from '../shared';
+import { z } from 'zod';
+export declare class EventHubTriggerDefinitionError extends AzFunctionsSystemError {
+}
+export interface EventHubArgProviderInput {
+    context: InvocationContext;
+    messages: unknown;
+}
+export type EventHubArgProvider = (input: EventHubArgProviderInput) => unknown;
+export type EventHubAsyncArgsProvider = (messages: unknown, context: InvocationContext) => Promise<unknown[]>;
+export declare const EventHubEventDataSchema: z.ZodObject<{
+    partitionContext: z.ZodObject<{
+        fullyQualifiedNamespace: z.ZodString;
+        consumerGroup: z.ZodString;
+        eventHubName: z.ZodString;
+        partitionId: z.ZodString;
+    }, z.core.$strip>;
+    enqueuedTimeUtc: z.ZodISODateTime;
+    offset: z.ZodInt;
+    partitionKey: z.ZodOptional<z.ZodString>;
+    sequenceNumber: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * Schema representing the raw Event Hub event data.
+ * Includes metadata such as partition InvocationCtx, enqueue time, offset, partition key, and sequence number.
+ * Can be used to strongly type the raw event data in handler methods.
+ *
+ * ```ts
+ * type EventHubEventData = {
+ *  partitionContext: {
+ *   consumerGroupName: string;
+ *   eventHubPath: string;
+ *  }
+ *  enqueuedTimeUtc: string;
+ *  offset: string;
+ *  partitionKey: string;
+ *  sequenceNumber: number;
+ *  };
+ * ```
+ * properties:
+ * - `partitionContext`: Metadata about the partition, including consumer group name and Event Hub path.
+ *   - `consumerGroupName`: The name of the consumer group.
+ *   - `eventHubPath`: The path of the Event Hub.
+ * - `enqueuedTimeUtc`: The UTC time when the event was enqueued, in ISO string format.
+ * - `offset`: The offset of the event in the partition.
+ * - `partitionKey`: The partition key of the event.
+ * - `sequenceNumber`: The sequence number of the event in the partition.
+ *
+ * @example
+ * ```ts
+ * const eventData: EventHubEventData = {
+ *   partitionContext: {
+ *     consumerGroupName: 'my-consumer-group',
+ *     eventHubPath: 'my-event-hub',
+ *   },
+ *   enqueuedTimeUtc: '2023-10-01T12:00:00Z',
+ *   offset: '12345',
+ *   partitionKey: 'my-partition-key',
+ *   sequenceNumber: 67890,
+ * };
+ * ```
+ */
+export type EventHubEventData = z.infer<typeof EventHubEventDataSchema>;
+export type EventHubMessageBaseWrapper<PAYLOAD = unknown, PROPERTIES = undefined, SYSTEM_PROPERTIES = undefined> = {
+    payload: PAYLOAD;
+} & (PROPERTIES extends undefined ? object : {
+    properties: PROPERTIES;
+}) & (SYSTEM_PROPERTIES extends undefined ? object : {
+    systemProperties: SYSTEM_PROPERTIES;
+});
+export type SafeWrapper<T, P> = ({
+    valid: true;
+} & T) | ({
+    valid: false;
+    error: unknown;
+} & P);
+export type SafeEventHubMessageWrapper<PAYLOAD = unknown, PROPERTIES = undefined, SYSTEM_PROPERTIES = undefined> = SafeWrapper<EventHubMessageBaseWrapper<PAYLOAD, PROPERTIES, SYSTEM_PROPERTIES>, EventHubMessageBaseWrapper<unknown, unknown, unknown>>;
+/**
+ * Wrapper for Event Hub Messages, including payload, properties, system properties, and optionally the raw event data.
+ * It allows for flexible typing of the Message components. Can be used to strongly type the Message structure in handler methods.
+ *
+ * Type Parameters:
+ * - `PAYLOAD`: The type of the Message payload.
+ * - `PROPERTIES`: The type of the custom properties of the Message. If not provided, properties will be omitted.
+ * - `SYSTEM_PROPERTIES`: The type of the system properties of the Message. If not provided, system properties will be omitted.
+ * - `EVENT_DATA`: If set to true, includes the raw Event Hub event data in the wrapper.
+ *
+ * @example
+ * ```ts
+ * const eventPayloadSchema = z.object({ id: z.string(), value: z.number() });
+ * type EventPayload = z.infer<typeof eventPayloadSchema>;
+ *
+ * const eventPropertiesSchema = z.object({ source: z.string() });
+ * type EventProperties = z.infer<typeof eventPropertiesSchema>;
+ *
+ * type MyEventHubMessage = EventHubMessageWrapper<EventPayload, EventProperties, undefined, true>;
+ */
+export type EventHubMessageWrapper<PAYLOAD = unknown, PROPERTIES = undefined, SYSTEM_PROPERTIES = undefined, EVENT_DATA extends true | undefined = undefined> = SafeEventHubMessageWrapper<PAYLOAD, PROPERTIES, SYSTEM_PROPERTIES> & (EVENT_DATA extends undefined ? object : {
+    eventData: EventHubEventData;
+});

package/dist/src/event-hub-handler/event-hub-trigger-support.factory.d.ts

@@ -0,0 +1,10 @@
+import { EventHubHandlerArgMetadata, EventHubHandlerCardinality } from './decorators';
+import { EventHubAsyncArgsProvider } from './event-hub-handler.model';
+export declare class EventHubTriggerSupportFactory {
+    buildArgProviders(args: EventHubHandlerArgMetadata[], cardinality?: EventHubHandlerCardinality): EventHubAsyncArgsProvider;
+    private getArgsProvider;
+    private getMessageProvider;
+    private validateMessage;
+    private getMessagesProvider;
+    private provideExtendedMessageSchema;
+}

package/dist/src/event-hub-handler/event-hub-trigger.model.d.ts

@@ -0,0 +1,39 @@
+import z from 'zod';
+declare const partitionContextSchema: z.ZodObject<{
+    fullyQualifiedNamespace: z.ZodString;
+    consumerGroup: z.ZodString;
+    eventHubName: z.ZodString;
+    partitionId: z.ZodString;
+}, z.core.$strip>;
+export type PartitionContext = z.infer<typeof partitionContextSchema>;
+export declare const triggerMetadataOneSchema: z.ZodObject<{
+    enqueuedTimeUtc: z.ZodISODateTime;
+    offset: z.ZodInt;
+    partitionKey: z.ZodString;
+    sequenceNumber: z.ZodInt;
+    properties: z.ZodRecord<z.ZodString, z.ZodAny>;
+    systemProperties: z.ZodRecord<z.ZodString, z.ZodAny>;
+    partitionContext: z.ZodObject<{
+        fullyQualifiedNamespace: z.ZodString;
+        consumerGroup: z.ZodString;
+        eventHubName: z.ZodString;
+        partitionId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type TriggerMetadataOne = z.infer<typeof triggerMetadataOneSchema>;
+export declare const triggerMetadataManySchema: z.ZodObject<{
+    enqueuedTimeUtcArray: z.ZodArray<z.ZodISODateTime>;
+    offsetArray: z.ZodArray<z.ZodInt>;
+    partitionKeyArray: z.ZodArray<z.ZodString>;
+    sequenceNumberArray: z.ZodArray<z.ZodInt>;
+    propertiesArray: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    systemPropertiesArray: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    partitionContext: z.ZodObject<{
+        fullyQualifiedNamespace: z.ZodString;
+        consumerGroup: z.ZodString;
+        eventHubName: z.ZodString;
+        partitionId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type TriggerMetadataMany = z.infer<typeof triggerMetadataManySchema>;
+export {};

package/dist/src/event-hub-handler/event-hub-triggers-registration.service.d.ts

@@ -0,0 +1,18 @@
+import { LoggerFactory } from '../logger';
+import { TriggerHandlerClass } from '../shared';
+import { EventHubHandlerMetadata, EventHubTriggerMetadata } from './decorators/index';
+import { EventHubHandlerMetadataReader } from './event-hub-handler-metadata.reader';
+export interface EventhubTriggerRegistration {
+    triggerId: string;
+    triggerMethod: string;
+    handlerMetadata: EventHubHandlerMetadata;
+    triggerMetadata: EventHubTriggerMetadata;
+}
+export type RegisterCallback = (triggerRegistration: EventhubTriggerRegistration) => void;
+export declare class EventHubTriggersRegistrationService {
+    private readonly metadataReader;
+    private readonly logger;
+    constructor(loggerFactory: LoggerFactory, metadataReader: EventHubHandlerMetadataReader);
+    registerTriggers(handlerClass: TriggerHandlerClass, registerCallback: RegisterCallback): void;
+    private getOperationMetadata;
+}

package/dist/src/event-hub-handler/index.d.ts

@@ -0,0 +1,4 @@
+import { ContainerModule } from 'inversify';
+export * from './decorators';
+export { EventHubMessageWrapper } from './event-hub-handler.model';
+export declare const EventHubHandlersModule: ContainerModule;

package/dist/src/framework.container.d.ts

@@ -0,0 +1,6 @@
+import { Container } from 'inversify';
+import { LoggerConfiguration } from './logger';
+export declare function createContainers(loggerConfiguration?: LoggerConfiguration): {
+    frameworkContainer: Container;
+    platformContainer: Container;
+};