@lafken/queue 0.10.1

package/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Aníbal Emilio Jorquera Cornejo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,247 @@
+# @lafken/queue
+
+Define and consume Amazon SQS queues using TypeScript decorators. `@lafken/queue` lets you declare Standard and FIFO queues, map message data to typed handler parameters, and send messages at runtime through a built-in service client.
+
+## Installation
+
+```bash
+npm install @lafken/queue
+```
+
+## Getting Started
+
+Define a queue class with `@Queue`, add consumer methods with `@Standard` or `@Fifo`, and register everything through `QueueResolver`:
+
+```typescript
+import { createApp, createModule } from '@lafken/main';
+import { QueueResolver } from '@lafken/queue/resolver';
+import { Queue, Standard, Payload, Param, Event } from '@lafken/queue/main';
+
+// 1. Define the message payload
+@Payload()
+export class OrderMessage {
+  @Param({ source: 'body', parse: true })
+  orderId: string;
+
+  @Param({ source: 'body', parse: true })
+  total: number;
+}
+
+// 2. Define the queue and its consumer
+@Queue()
+export class OrderQueue {
+  @Standard({ batchSize: 5, visibilityTimeout: 60 })
+  processOrder(@Event(OrderMessage) message: OrderMessage) {
+    console.log(`Processing order ${message.orderId}`);
+  }
+}
+
+// 3. Register in a module
+const orderModule = createModule({
+  name: 'order',
+  resources: [OrderQueue],
+});
+
+// 4. Add the resolver to the app
+createApp({
+  name: 'my-app',
+  resolvers: [new QueueResolver()],
+  modules: [orderModule],
+});
+```
+
+Each `@Standard` or `@Fifo` method becomes an independent Lambda function with its own SQS queue and event source mapping.
+
+## Features
+
+### Queue Class
+
+Use the `@Queue` decorator to group related queue consumers in a single class. A queue class can contain multiple `@Standard` and `@Fifo` handlers:
+
+```typescript
+import { Queue, Standard, Fifo } from '@lafken/queue/main';
+
+@Queue()
+export class NotificationQueue {
+  @Standard({ queueName: 'email-notifications' })
+  sendEmail() { }
+
+  @Fifo({ queueName: 'sms-notifications', contentBasedDeduplication: true })
+  sendSms() { }
+}
+```
+
+### Standard Queues
+
+Use the `@Standard` decorator to create a standard (non-FIFO) SQS queue consumer. Messages are delivered at least once with best-effort ordering:
+
+```typescript
+@Standard({
+  queueName: 'reports',
+  batchSize: 10,
+  visibilityTimeout: 120,
+  maxConcurrency: 5,
+})
+generateReport(@Event(ReportMessage) message: ReportMessage) {
+  // Process up to 10 messages per invocation
+}
+```
+
+If `queueName` is omitted, the method name is used as the queue name.
+
+#### Standard Queue Options
+
+| Option                | Type     | Description                                                        |
+| --------------------- | -------- | ------------------------------------------------------------------ |
+| `queueName`           | `string` | Queue name (defaults to the method name)                           |
+| `batchSize`           | `1–10`   | Number of messages per Lambda invocation                           |
+| `visibilityTimeout`   | `number` | Seconds a message is hidden from other consumers while processing  |
+| `deliveryDelay`       | `number` | Seconds to delay message delivery after it is sent                 |
+| `retentionPeriod`     | `number` | Seconds messages are retained before automatic deletion            |
+| `maxMessageSizeBytes` | `number` | Maximum message size in bytes                                      |
+| `maxConcurrency`      | `number` | Maximum concurrent Lambda invocations for this queue               |
+| `maxBatchingWindow`   | `number` | Seconds to wait gathering messages into a batch before invoking    |
+| `lambda`              | `object` | Lambda-specific configuration (memory, timeout, etc.)              |
+
+### FIFO Queues
+
+Use the `@Fifo` decorator for FIFO (First-In-First-Out) queues. FIFO queues guarantee exactly-once processing and strict message ordering. The queue name automatically gets a `.fifo` suffix:
+
+```typescript
+@Fifo({
+  queueName: 'payment-processing',
+  contentBasedDeduplication: true,
+  batchSize: 1,
+})
+processPayment(@Event(PaymentMessage) message: PaymentMessage) {
+  // Messages are processed in exact send order
+}
+```
+
+FIFO queues support all standard queue options plus:
+
+| Option                      | Type      | Description                                                     |
+| --------------------------- | --------- | --------------------------------------------------------------- |
+| `contentBasedDeduplication` | `boolean` | Use message content to generate deduplication IDs automatically |
+
+> [!NOTE]
+> FIFO queues automatically enable `ReportBatchItemFailures`, allowing partial batch failure reporting.
+
+### Message Payload
+
+Use `@Payload` on a class to define the structure of SQS messages. Decorate each property with `@Param` to specify where the value is extracted from in the SQS record:
+
+```typescript
+import { Payload, Param } from '@lafken/queue/main';
+
+@Payload()
+export class TaskMessage {
+  @Param({ source: 'attribute', type: String })
+  correlationId: string;
+
+  @Param({ source: 'body', parse: true })
+  taskName: string;
+
+  @Param({ source: 'body', parse: true })
+  priority: number;
+}
+```
+
+#### @Param Options
+
+| Option   | Type                      | Default       | Description                                      |
+| -------- | ------------------------- | ------------- | ------------------------------------------------ |
+| `source` | `'attribute' \| 'body'`   | `'attribute'` | Where to extract the value from the SQS record   |
+| `parse`  | `boolean`                 | `false`       | JSON-parse the message body before extraction     |
+| `type`   | `String \| Number \| ...` | inferred      | Data type of the extracted value                  |
+| `name`   | `string`                  | property name | Override the field name used for extraction       |
+
+- **`source: 'attribute'`** — reads from SQS message attributes (supports `String` and `Number` types)
+- **`source: 'body'`** — reads from the message body. Set `parse: true` to JSON-parse the body and extract a specific field
+
+> [!NOTE]
+> Only one `@Param` with `source: 'body'` and `parse: false` (raw body) is allowed per handler.
+
+#### @Field Decorator
+
+Use `@Field` to include a property in the payload schema without specifying an extraction source:
+
+```typescript
+import { Payload, Field } from '@lafken/queue/main';
+
+@Payload()
+export class SimpleMessage {
+  @Field()
+  action: string;
+
+  @Field()
+  timestamp: number;
+}
+```
+
+### Consuming Messages
+
+Bind a typed payload to a handler method using the `@Event` parameter decorator. Pass the payload class so the framework can automatically extract and map fields from the SQS record at runtime:
+
+```typescript
+import { Queue, Standard, Event } from '@lafken/queue/main';
+
+@Queue()
+export class AlertQueue {
+  @Standard({ queueName: 'alerts', batchSize: 5 })
+  processAlert(@Event(AlertMessage) alert: AlertMessage) {
+    console.log(`Alert from ${alert.source}: ${alert.message}`);
+  }
+}
+```
+
+### Sending Messages
+
+Use `QueueService` at runtime to send messages to any SQS queue:
+
+```typescript
+import { QueueService } from '@lafken/queue/service';
+
+// Send a single message
+await QueueService.sendMessage({
+  url: 'https://sqs.us-east-1.amazonaws.com/123456789/orders',
+  body: { orderId: 'ord-123', total: 49.99 },
+  delay: 10,
+});
+
+// Send to a FIFO queue
+await QueueService.sendMessage({
+  url: 'https://sqs.us-east-1.amazonaws.com/123456789/payments.fifo',
+  body: { paymentId: 'pay-456', amount: 100 },
+  groupId: 'customer-789',
+  deduplicationId: 'pay-456',
+});
+```
+
+#### SendMessage Options
+
+| Option              | Type                               | Description                                        |
+| ------------------- | ---------------------------------- | -------------------------------------------------- |
+| `url`               | `string`                           | Full SQS queue URL                                 |
+| `body`              | `any`                              | Message body (automatically JSON-stringified)      |
+| `attributes`        | `Record<string, string \| number>` | SQS message attributes                            |
+| `delay`             | `number`                           | Delay in seconds before the message becomes visible |
+| `groupId`           | `string`                           | Message group ID (FIFO queues only)                |
+| `deduplicationId`   | `string`                           | Deduplication ID (FIFO queues only)                |
+
+### Sending Batch Messages
+
+Send multiple messages in a single API call:
+
+```typescript
+import { QueueService } from '@lafken/queue/service';
+
+await QueueService.sendBatchMessage({
+  url: 'https://sqs.us-east-1.amazonaws.com/123456789/tasks',
+  messages: [
+    { body: { task: 'resize-image', fileId: 'f1' } },
+    { body: { task: 'resize-image', fileId: 'f2' }, delay: 30 },
+    { body: { task: 'generate-thumbnail', fileId: 'f3' } },
+  ],
+});
+```

package/lib/index.d.ts

@@ -0,0 +1 @@
+export * from './main';

package/lib/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./main"), exports);

package/lib/main/event/event.d.ts

@@ -0,0 +1,99 @@
+import type { ParamProps } from './event.types';
+export declare const queueFieldKey: string;
+export declare const queuePayloadKey: string;
+/**
+ * Class decorator that declares a class as an SQS message payload.
+ *
+ * The decorated class defines the structure of data carried in a queue
+ * message. Use `@Param` or `@Field` on its properties to describe
+ * where each value is extracted from in the SQS record (message
+ * attributes or body).
+ *
+ * Works both at build time and at Lambda invocation time, so the
+ * same class can be used for sending and receiving messages.
+ *
+ * @param props - Optional payload configuration (e.g. a custom `name`).
+ *
+ * @example
+ * ```ts
+ * @Payload()
+ * export class OrderMessage {
+ *   @Param({ source: 'attribute' })
+ *   orderId: string;
+ *
+ *   @Param({ source: 'body', parse: true })
+ *   details: OrderDetails;
+ * }
+ * ```
+ */
+export declare const Payload: (props?: import("@lafken/common").PayloadProps | undefined) => (target: Function) => void;
+/**
+ * Property decorator that maps a class field to a value extracted
+ * from an SQS message.
+ *
+ * By default the value is read from a **message attribute** whose name
+ * matches the property. Set `source: 'body'` to extract it from the
+ * message body instead, and optionally enable `parse: true` to
+ * JSON-parse the body before extraction.
+ *
+ * @param props - Optional extraction configuration (source, type, parse).
+ *
+ * @example
+ * ```ts
+ * @Payload()
+ * export class NotificationMessage {
+ *   @Param({ source: 'attribute', type: String })
+ *   userId: string;
+ *
+ *   @Param({ source: 'body', parse: true })
+ *   content: NotificationContent;
+ * }
+ * ```
+ */
+export declare const Param: (props?: ParamProps | undefined) => (target: any, destinationName: string) => void;
+/**
+ * Property decorator that registers a class field as a generic
+ * queue message field.
+ *
+ * Unlike `@Param`, this decorator does not configure a specific
+ * extraction source or parsing behaviour — it simply marks the
+ * property for inclusion in the message payload schema.
+ *
+ * @param props - Optional field configuration (e.g. a custom `name` or `type`).
+ *
+ * @example
+ * ```ts
+ * @Payload()
+ * export class SimpleMessage {
+ *   @Field()
+ *   action: string;
+ *
+ *   @Field()
+ *   timestamp: number;
+ * }
+ * ```
+ */
+export declare const Field: (props?: import("@lafken/common").FieldProps | undefined) => (target: any, destinationName: string) => void;
+/**
+ * Parameter decorator that binds the incoming SQS event to a typed
+ * payload class on a handler method argument.
+ *
+ * Pass a class decorated with `@Payload` so the framework can
+ * automatically extract and map each field from the raw SQS record
+ * into a strongly-typed object at runtime.
+ *
+ * @param eventField - The payload class describing the expected
+ *                      message structure.
+ *
+ * @example
+ * ```ts
+ * @Queue()
+ * export class OrderQueue {
+ *   @Consumer()
+ *   process(@Event(OrderMessage) msg: OrderMessage) {
+ *     // msg fields are extracted from the SQS record
+ *   }
+ * }
+ * ```
+ */
+export declare const Event: (eventField: Function) => (target: any, methodName: string, _number: number) => void;

package/lib/main/event/event.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = exports.Field = exports.Param = exports.Payload = exports.queuePayloadKey = exports.queueFieldKey = void 0;
+const common_1 = require("@lafken/common");
+const queue_1 = require("../queue");
+exports.queueFieldKey = (0, common_1.createFieldName)(queue_1.RESOURCE_TYPE, common_1.FieldProperties.field);
+exports.queuePayloadKey = (0, common_1.createFieldName)(queue_1.RESOURCE_TYPE, common_1.FieldProperties.payload);
+/**
+ * Class decorator that declares a class as an SQS message payload.
+ *
+ * The decorated class defines the structure of data carried in a queue
+ * message. Use `@Param` or `@Field` on its properties to describe
+ * where each value is extracted from in the SQS record (message
+ * attributes or body).
+ *
+ * Works both at build time and at Lambda invocation time, so the
+ * same class can be used for sending and receiving messages.
+ *
+ * @param props - Optional payload configuration (e.g. a custom `name`).
+ *
+ * @example
+ * ```ts
+ * @Payload()
+ * export class OrderMessage {
+ *   @Param({ source: 'attribute' })
+ *   orderId: string;
+ *
+ *   @Param({ source: 'body', parse: true })
+ *   details: OrderDetails;
+ * }
+ * ```
+ */
+exports.Payload = (0, common_1.createPayloadDecorator)({
+    prefix: queue_1.RESOURCE_TYPE,
+    createUniqueId: false,
+    enableInLambdaInvocation: true,
+});
+/**
+ * Property decorator that maps a class field to a value extracted
+ * from an SQS message.
+ *
+ * By default the value is read from a **message attribute** whose name
+ * matches the property. Set `source: 'body'` to extract it from the
+ * message body instead, and optionally enable `parse: true` to
+ * JSON-parse the body before extraction.
+ *
+ * @param props - Optional extraction configuration (source, type, parse).
+ *
+ * @example
+ * ```ts
+ * @Payload()
+ * export class NotificationMessage {
+ *   @Param({ source: 'attribute', type: String })
+ *   userId: string;
+ *
+ *   @Param({ source: 'body', parse: true })
+ *   content: NotificationContent;
+ * }
+ * ```
+ */
+exports.Param = (0, common_1.createFieldDecorator)({
+    prefix: queue_1.RESOURCE_TYPE,
+    enableInLambdaInvocation: true,
+    getMetadata: (props) => {
+        const source = props?.source || 'attribute';
+        return {
+            source,
+            parse: props?.source === 'body' && !!props?.parse,
+        };
+    },
+});
+/**
+ * Property decorator that registers a class field as a generic
+ * queue message field.
+ *
+ * Unlike `@Param`, this decorator does not configure a specific
+ * extraction source or parsing behaviour — it simply marks the
+ * property for inclusion in the message payload schema.
+ *
+ * @param props - Optional field configuration (e.g. a custom `name` or `type`).
+ *
+ * @example
+ * ```ts
+ * @Payload()
+ * export class SimpleMessage {
+ *   @Field()
+ *   action: string;
+ *
+ *   @Field()
+ *   timestamp: number;
+ * }
+ * ```
+ */
+exports.Field = (0, common_1.createFieldDecorator)({
+    prefix: queue_1.RESOURCE_TYPE,
+    enableInLambdaInvocation: true,
+    getMetadata: () => ({}),
+});
+/**
+ * Parameter decorator that binds the incoming SQS event to a typed
+ * payload class on a handler method argument.
+ *
+ * Pass a class decorated with `@Payload` so the framework can
+ * automatically extract and map each field from the raw SQS record
+ * into a strongly-typed object at runtime.
+ *
+ * @param eventField - The payload class describing the expected
+ *                      message structure.
+ *
+ * @example
+ * ```ts
+ * @Queue()
+ * export class OrderQueue {
+ *   @Consumer()
+ *   process(@Event(OrderMessage) msg: OrderMessage) {
+ *     // msg fields are extracted from the SQS record
+ *   }
+ * }
+ * ```
+ */
+const Event = (eventField) => (0, common_1.createEventDecorator)({
+    prefix: queue_1.RESOURCE_TYPE,
+    enableInLambdaInvocation: true,
+})(eventField);
+exports.Event = Event;

package/lib/main/event/event.types.d.ts

@@ -0,0 +1,89 @@
+import type { ArrayField, BooleanField, FieldProps, NumberField, ObjectField, StringField } from '@lafken/common';
+export interface ParamAttributeProps extends Omit<FieldProps, 'type'> {
+    /**
+     * Attribute source.
+     *
+     * Specifies the source from which to obtain the attribute value.
+     * This can be used to map values from the event
+     * when processing messages.
+     */
+    source?: 'attribute';
+    /**
+     * Attribute type.
+     *
+     * Specifies the data type of the attribute. This can be used to
+     * enforce the type of the value extracted from the source before
+     * passing it to the consumer or processing logic.
+     */
+    type?: NumberConstructor | StringConstructor;
+}
+export interface ParamBodyUnparsedProps extends Omit<FieldProps, 'type'> {
+    /**
+     * Attribute source.
+     *
+     * Specifies the source from which to obtain the attribute value.
+     * This can be used to map values from the event
+     * when processing messages.
+     */
+    source: 'body';
+    /**
+     * Parse message body.
+     *
+     * Specifies whether the message body should be parsed and converted
+     * into a JavaScript object before being passed to the consumer.
+     */
+    parse?: false;
+    /**
+     * Attribute type.
+     *
+     * Specifies the data type of the attribute. This can be used to
+     * enforce the type of the value extracted from the source before
+     * passing it to the consumer or processing logic.
+     */
+    type?: StringConstructor;
+}
+export interface ParamBodyParsedProps extends Omit<FieldProps, 'type'> {
+    /**
+     * Attribute source.
+     *
+     * Specifies the source from which to obtain the attribute value.
+     * This can be used to map values from the event
+     * when processing messages.
+     */
+    source: 'body';
+    /**
+     * Parse message body.
+     *
+     * Specifies whether the message body should be parsed and converted
+     * into a JavaScript object before being passed to the consumer.
+     */
+    parse: true;
+    /**
+     * Attribute type.
+     *
+     * Specifies the data type of the attribute. This can be used to
+     * enforce the type of the value extracted from the source before
+     * passing it to the consumer or processing logic.
+     */
+    type?: StringConstructor | Function | [Function];
+}
+export type ParamProps = ParamAttributeProps | ParamBodyUnparsedProps | ParamBodyParsedProps;
+export type Source = Exclude<ParamProps['source'], undefined>;
+interface QueueParamBase {
+    source: Source;
+    parse: boolean;
+}
+export interface QueueStringParam extends StringField, QueueParamBase {
+}
+export interface QueueNumberParam extends NumberField, QueueParamBase {
+}
+export interface QueueBooleanParam extends BooleanField, QueueParamBase {
+}
+export interface QueueObjectParam extends Omit<ObjectField, 'properties'>, QueueParamBase {
+    properties: QueueParamMetadata[];
+}
+export interface QueueArrayParam extends Omit<ArrayField, 'items'>, QueueParamBase {
+    items: QueueParamMetadata;
+}
+export type QueueParamMetadata = QueueStringParam | QueueNumberParam | QueueBooleanParam | QueueObjectParam | QueueArrayParam;
+export {};

package/lib/main/event/event.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/main/event/index.d.ts

@@ -0,0 +1,2 @@
+export * from './event';
+export * from './event.types';

package/lib/main/event/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./event"), exports);
+__exportStar(require("./event.types"), exports);

package/lib/main/index.d.ts

@@ -0,0 +1,2 @@
+export * from './event';
+export * from './queue';

package/lib/main/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./event"), exports);
+__exportStar(require("./queue"), exports);

package/lib/main/queue/index.d.ts

@@ -0,0 +1,2 @@
+export * from './queue';
+export * from './queue.types';

package/lib/main/queue/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./queue"), exports);
+__exportStar(require("./queue.types"), exports);