@lafken/common 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,414 @@
+# @lafken/common
+
+`@lafken/common` is the core utility package for the Lafken framework. It provides the decorator factory functions, metadata reflection utilities, and shared types that power every `@lafken/*` package. If a Lafken package defines a decorator or reads infrastructure metadata, it depends on `@lafken/common`.
+
+## Installation
+
+```bash
+pnpm add @lafken/common
+```
+
+## Overview
+
+Lafken uses TypeScript decorators to declare infrastructure. This package provides the factories that create those decorators and the utilities that read the metadata they produce:
+
+| Factory                    | Level  | Purpose                                      |
+| -------------------------- | ------ | -------------------------------------------- |
+| `createResourceDecorator`  | Class  | Mark a class as a deployable resource         |
+| `createLambdaDecorator`    | Method | Mark a method as a Lambda handler             |
+| `createEventDecorator`     | Param  | Bind a method parameter to the Lambda event   |
+| `createFieldDecorator`     | Prop   | Describe a typed field inside a payload class |
+| `createPayloadDecorator`   | Class  | Define a named payload schema                |
+
+## Decorator Factories
+
+### `createResourceDecorator`
+
+Creates a **class-level** decorator that marks a class as an infrastructure resource. The factory automatically captures the resource name, the file path and folder (used for Lambda bundling), and any custom metadata you define.
+
+```typescript
+import { createResourceDecorator } from '@lafken/common';
+
+export const RESOURCE_TYPE = 'MY_SERVICE' as const;
+
+export interface MyServiceProps {
+  name?: string;
+  retryCount?: number;
+}
+
+export const MyService = createResourceDecorator<MyServiceProps>({
+  type: RESOURCE_TYPE,
+  callerFileIndex: 5,                       // Stack-trace index to resolve caller file
+  getMetadata: (props) => ({                // Optional — transform props before storing
+    ...props,
+    retryCount: props.retryCount ?? 3,
+  }),
+});
+```
+
+Usage:
+
+```typescript
+@MyService({ name: 'notifications', retryCount: 5 })
+export class NotificationService { ... }
+```
+
+**Captured metadata** (`ResourceMetadata`):
+
+| Field          | Description                              |
+| -------------- | ---------------------------------------- |
+| `type`         | Resolver identifier (`MY_SERVICE`)       |
+| `name`         | Explicit name or the class name          |
+| `foldername`   | Directory of the decorated file          |
+| `filename`     | File name (without `.js` extension)      |
+| `originalName` | Original class name (for asset naming)   |
+| `minify`       | Whether to minify the bundle (`true`)    |
+
+### `createLambdaDecorator`
+
+Creates a **method-level** decorator that registers a method as a Lambda handler. It stores handler metadata and rewrites the method descriptor so the framework can inject arguments (`@Event`, `@Context`) at runtime.
+
+```typescript
+import { createLambdaDecorator } from '@lafken/common';
+import type { LambdaMetadata } from '@lafken/common';
+
+export interface PublishProps {
+  name: string;
+  lambda?: LambdaProps;
+}
+
+export interface PublishMetadata extends PublishProps {
+  name: string;
+}
+
+export const Publish = (props: PublishProps) =>
+  createLambdaDecorator<PublishProps, PublishMetadata>({
+    getLambdaMetadata: (props, methodName) => ({
+      ...props,
+      name: methodName,
+    }),
+  })(props);
+```
+
+Usage:
+
+```typescript
+class NotificationService {
+  @Publish({ name: 'send-email' })
+  sendEmail(@Event() event: EmailPayload) {
+    // handler logic
+  }
+}
+```
+
+**`LambdaProps`** — Optional Lambda-level configuration available through the `lambda` property:
+
+| Property      | Type                | Description                                   |
+| ------------- | ------------------- | --------------------------------------------- |
+| `timeout`     | `number`            | Execution timeout in seconds                  |
+| `memory`      | `number`            | Memory allocation in MB                       |
+| `runtime`     | `24 \| 22 \| 20`   | Node.js runtime version                       |
+| `services`    | `ServicesValues`    | IAM service permissions                       |
+| `env`         | `EnvironmentValue`  | Environment variables (static or dynamic)     |
+| `tags`        | `Record<string, string>` | Resource tags                            |
+| `enableTrace` | `boolean`           | Enable AWS X-Ray tracing                      |
+
+### `createEventDecorator`
+
+Creates a **parameter-level** decorator that binds a method parameter to the incoming Lambda event. It works with `createFieldDecorator` to map typed payload classes onto the raw event.
+
+```typescript
+import { createEventDecorator } from '@lafken/common';
+
+export const Event = createEventDecorator({
+  prefix: 'my-service',
+  enableInLambdaInvocation: false,  // Only capture metadata during build
+});
+```
+
+Usage:
+
+```typescript
+class NotificationService {
+  @Publish({ name: 'send-email' })
+  sendEmail(@Event(EmailPayload) event: EmailPayload) { ... }
+}
+```
+
+### `Context`
+
+A built-in parameter decorator that injects the Lambda execution context:
+
+```typescript
+import { Context } from '@lafken/common';
+
+class MyService {
+  @Handler()
+  process(@Event(Input) event: Input, @Context() ctx: any) {
+    console.log(ctx.functionName);
+  }
+}
+```
+
+### `createFieldDecorator`
+
+Creates a **property-level** decorator that describes a typed field inside a payload class. The field metadata is collected by resolvers to build event schemas (e.g., Step Functions input/output, API request bodies).
+
+Supported types: `String`, `Number`, `Boolean`, nested classes, and arrays.
+
+```typescript
+import { createFieldDecorator } from '@lafken/common';
+
+export const Field = createFieldDecorator({
+  prefix: 'my-service',
+  getMetadata: () => ({}),
+});
+```
+
+Usage:
+
+```typescript
+class Address {
+  @Field()
+  street: string;
+
+  @Field()
+  city: string;
+}
+
+class UserPayload {
+  @Field({ name: 'user_name' })   // Rename the field in the schema
+  name: string;
+
+  @Field()
+  age: number;
+
+  @Field({ type: Address })        // Nested object
+  address: Address;
+
+  @Field({ type: [String] })       // Array of primitives
+  tags: string[];
+}
+```
+
+### `createPayloadDecorator`
+
+Creates a **class-level** decorator that gives a payload class a name and optional metadata. This identity is used when resolvers reference the payload in generated infrastructure.
+
+```typescript
+import { createPayloadDecorator } from '@lafken/common';
+
+export const Payload = createPayloadDecorator({
+  prefix: 'my-service',
+  createUniqueId: true,   // Append a counter if names collide
+});
+```
+
+Usage:
+
+```typescript
+@Payload({ name: 'CreateUserInput' })
+class CreateUserInput {
+  @Field()
+  email: string;
+}
+```
+
+## Metadata Utilities
+
+Resolvers use these functions to read the metadata produced by the decorators above.
+
+### `getResourceMetadata`
+
+Returns the `ResourceMetadata` stored on a class by `createResourceDecorator`:
+
+```typescript
+import { getResourceMetadata } from '@lafken/common';
+
+const metadata = getResourceMetadata(NotificationService);
+// { type: 'MY_SERVICE', name: 'notifications', foldername: '...', ... }
+```
+
+### `getResourceHandlerMetadata`
+
+Returns an array of handler metadata stored by `createLambdaDecorator`:
+
+```typescript
+import { getResourceHandlerMetadata } from '@lafken/common';
+
+const handlers = getResourceHandlerMetadata<PublishMetadata>(NotificationService);
+// [{ name: 'sendEmail', ... }]
+```
+
+### `getMetadataByKey` / `getMetadataPrototypeByKey`
+
+Low-level helpers to read any Reflect metadata by key from a class or its prototype:
+
+```typescript
+import { getMetadataByKey, getMetadataPrototypeByKey } from '@lafken/common';
+
+const payload = getMetadataByKey<PayloadMetadata>(MyClass, 'my-service:lafken:payload');
+const fields  = getMetadataPrototypeByKey<FieldMetadata[]>(MyClass, 'my-service:lafken:field');
+```
+
+## Build Environment
+
+Decorators only capture metadata when the build environment flag is set. This prevents metadata side-effects during normal runtime execution.
+
+- **`isBuildEnvironment()`** — Returns `true` when the `LAFKEN_CONTEXT` environment variable equals `BUILD`.
+- **`enableBuildEnvVariable()`** — Sets the flag. **Required in tests** before declaring any decorated class.
+
+```typescript
+import { enableBuildEnvVariable } from '@lafken/common';
+
+describe('My resolver', () => {
+  enableBuildEnvVariable();
+
+  @MyService({ name: 'test' })
+  class TestResource { ... }
+
+  it('should capture metadata', () => {
+    const meta = getResourceMetadata(TestResource);
+    expect(meta.name).toBe('test');
+  });
+});
+```
+
+## String Utilities
+
+General-purpose string helpers used throughout the framework:
+
+| Function               | Description                                          | Example                          |
+| ---------------------- | ---------------------------------------------------- | -------------------------------- |
+| `capitalize(str)`      | Uppercase first letter                               | `'hello'` → `'Hello'`           |
+| `kebabCase(str)`       | Convert to kebab-case                                | `'MyService'` → `'my-service'`  |
+| `cleanString(str)`     | Remove non-alphanumeric characters                   | `'a-b_c'` → `'abc'`            |
+| `cleanAndCapitalize(str)` | Clean + capitalize each word                      | `'my-service'` → `'MyService'`  |
+| `cleanTemplateString(str)` | Trim + collapse multiline strings into one line  | —                                |
+
+## Shared Types
+
+### Services & Permissions
+
+The `Services` type provides typed IAM permission declarations for Lambda handlers:
+
+```typescript
+import type { Services } from '@lafken/common';
+
+// Shorthand — grants full service access
+const services: Services[] = ['dynamodb', 's3'];
+
+// Fine-grained — specific actions and resources
+const services: Services[] = [
+  { type: 'dynamodb', permissions: ['GetItem', 'PutItem'] },
+  { type: 's3', permissions: ['GetObject'], resources: ['arn:aws:s3:::my-bucket/*'] },
+  { type: 'custom', serviceName: 'ses', permissions: ['SendEmail'] },
+];
+```
+
+Supported service types: `dynamodb`, `s3`, `lambda`, `cloudwatch`, `sqs`, `state_machine`, `kms`, `ssm`, `event`, and `custom`.
+
+### Environment Variables
+
+```typescript
+import type { EnvironmentValue } from '@lafken/common';
+
+// Static values
+const env: EnvironmentValue = { TABLE_NAME: 'users' };
+
+// Dynamic values — resolved at deploy time via resource references
+const env: EnvironmentValue = ({ getResourceValue }) => ({
+  TABLE_ARN: getResourceValue('dynamo::users-table', 'arn'),
+});
+```
+
+### Duration
+
+```typescript
+import type { Duration } from '@lafken/common';
+
+const timeout: Duration = 30;                              // seconds
+const ttl: Duration = { type: 'days', duration: 7 };       // 7 days
+```
+
+### Type-Safe Resource References
+
+The package provides augmentable interfaces that enable type-safe resource names across modules. Packages extend these interfaces so that `getResourceValue` calls are validated at compile time:
+
+```typescript
+// In your lafken-types.d.ts
+declare module '@lafken/common' {
+  interface ModulesAvailable {
+    core: {
+      Queue: { 'email-queue': string };
+    };
+  }
+  interface DynamoTableAvailable {
+    'users-table': string;
+  }
+}
+```
+
+## API Reference
+
+### Decorator Factories
+
+| Export                     | Description                                |
+| -------------------------- | ------------------------------------------ |
+| `createResourceDecorator`  | Factory for class-level resource decorators |
+| `createLambdaDecorator`    | Factory for method-level handler decorators |
+| `createEventDecorator`     | Factory for parameter-level event binding   |
+| `createFieldDecorator`     | Factory for property-level field metadata   |
+| `createPayloadDecorator`   | Factory for class-level payload naming      |
+| `Context`                  | Parameter decorator for Lambda context      |
+
+### Metadata Readers
+
+| Export                       | Description                                |
+| ---------------------------- | ------------------------------------------ |
+| `getResourceMetadata`        | Read class resource metadata               |
+| `getResourceHandlerMetadata` | Read method handler metadata               |
+| `getMetadataByKey`           | Read metadata by key from a class          |
+| `getMetadataPrototypeByKey`  | Read metadata by key from a prototype      |
+
+### Utilities
+
+| Export                    | Description                              |
+| ------------------------- | ---------------------------------------- |
+| `enableBuildEnvVariable`  | Enable build mode for decorator capture  |
+| `isBuildEnvironment`      | Check if build mode is active            |
+| `getCallerFileName`       | Resolve the caller file from the stack   |
+| `capitalize`              | Capitalize a string                      |
+| `kebabCase`               | Convert to kebab-case                    |
+| `cleanString`             | Strip non-alphanumeric characters        |
+| `cleanAndCapitalize`      | Clean and capitalize each word           |
+| `cleanTemplateString`     | Collapse multiline string to one line    |
+
+### Constants
+
+| Export                 | Description                          |
+| ---------------------- | ------------------------------------ |
+| `LAFKEN_CONTEXT`       | Environment variable name            |
+| `LAFKEN_CONTEXT_VALUE` | Expected value for build mode        |
+
+### Key Types
+
+| Export               | Description                                         |
+| -------------------- | --------------------------------------------------- |
+| `ResourceProps`      | Base props for resource decorators                   |
+| `ResourceMetadata`   | Metadata shape stored by resource decorators         |
+| `LambdaProps`        | Lambda configuration (timeout, memory, runtime, ...) |
+| `LambdaMetadata`     | Metadata shape for handler methods                   |
+| `FieldMetadata`      | Discriminated union of field types                   |
+| `PayloadMetadata`    | Metadata shape for payload classes                   |
+| `Services`           | IAM permission declaration type                      |
+| `ServicesValues`     | Array or function returning `Services[]`             |
+| `EnvironmentValue`   | Static or dynamic environment variables              |
+| `Duration`           | Seconds or `{ type, duration }` object               |
+| `ClassResource`      | Generic class constructor type                       |
+| `GetResourceValue`   | Callback type for cross-resource references          |
+| `DeepPartial<T>`     | Recursive partial type utility                       |
+
+## License
+
+MIT

package/lib/constants/env.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const LAFKEN_CONTEXT = "LAFKEN_CONTEXT";
+export declare const LAFKEN_CONTEXT_VALUE = "BUILD";

package/lib/constants/env.constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAFKEN_CONTEXT_VALUE = exports.LAFKEN_CONTEXT = void 0;
+exports.LAFKEN_CONTEXT = 'LAFKEN_CONTEXT';
+exports.LAFKEN_CONTEXT_VALUE = 'BUILD';

package/lib/constants/index.d.ts

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

package/lib/constants/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("./env.constants"), exports);

package/lib/decorators/field/field.d.ts

@@ -0,0 +1,9 @@
+import 'reflect-metadata';
+import { type AllowedTypes, type BaseFieldMetadata, type CreateFieldDecoratorProps, FieldProperties, type FieldProps, type PrimitiveTypes } from './field.types';
+export declare const primitiveTypeValues: Set<PrimitiveTypes>;
+export declare const primitiveTypeofValues: Set<string>;
+export declare const mapTypeofValueToPrimitiveType: Record<string, PrimitiveTypes>;
+export declare const getPrimitiveType: (type: AllowedTypes) => PrimitiveTypes | undefined;
+export declare const getEventFields: (prefix: string, target?: AllowedTypes, name?: string) => BaseFieldMetadata | undefined;
+export declare const createFieldDecorator: <T extends FieldProps, M>({ prefix, enableInLambdaInvocation, getMetadata, }: CreateFieldDecoratorProps<T, M>) => (props?: T) => (target: any, destinationName: string) => void;
+export declare const createFieldName: (prefix: string, type: FieldProperties) => string;

package/lib/decorators/field/field.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFieldName = exports.createFieldDecorator = exports.getEventFields = exports.getPrimitiveType = exports.mapTypeofValueToPrimitiveType = exports.primitiveTypeofValues = exports.primitiveTypeValues = void 0;
+require("reflect-metadata");
+const utils_1 = require("../../utils");
+const build_env_utils_1 = require("../../utils/build-env.utils");
+const field_types_1 = require("./field.types");
+exports.primitiveTypeValues = new Set([
+    'Boolean',
+    'Number',
+    'String',
+]);
+exports.primitiveTypeofValues = new Set(['boolean', 'number', 'string']);
+exports.mapTypeofValueToPrimitiveType = {
+    boolean: 'Boolean',
+    number: 'Number',
+    string: 'String',
+};
+const getPrimitiveType = (type) => {
+    if (type === String)
+        return 'String';
+    if (type === Number)
+        return 'Number';
+    if (type === Boolean)
+        return 'Boolean';
+};
+exports.getPrimitiveType = getPrimitiveType;
+const getEventFields = (prefix, target, name = 'event') => {
+    if (!target) {
+        return undefined;
+    }
+    return getFieldMetadata({
+        destinationName: name,
+        type: `${name}_type`,
+        fieldProps: {
+            type: target,
+        },
+        prefix,
+    });
+};
+exports.getEventFields = getEventFields;
+const getObjectMetadata = (metadata, payloadClass, prefix) => {
+    const payloadMetadata = (0, utils_1.getMetadataByKey)(payloadClass, (0, exports.createFieldName)(prefix, field_types_1.FieldProperties.payload)) || {
+        name: payloadClass.name,
+        id: payloadClass.name,
+    };
+    const properties = (0, utils_1.getMetadataPrototypeByKey)(payloadClass, (0, exports.createFieldName)(prefix, field_types_1.FieldProperties.field));
+    if (!properties?.length) {
+        throw new Error(`should include Field properties in ${payloadClass.name} class`);
+    }
+    return {
+        ...metadata,
+        properties,
+        type: 'Object',
+        payload: payloadMetadata,
+    };
+};
+const getFieldMetadata = (props) => {
+    const { fieldProps, destinationName, type, prefix } = props;
+    const metadata = {
+        destinationName,
+        name: fieldProps?.name || destinationName,
+    };
+    let primitiveType = (0, exports.getPrimitiveType)(type);
+    if (!primitiveType && fieldProps?.type) {
+        primitiveType = (0, exports.getPrimitiveType)(fieldProps.type);
+    }
+    const typeHasValue = exports.mapTypeofValueToPrimitiveType[typeof fieldProps?.type];
+    if (fieldProps?.type !== undefined) {
+        if (typeof fieldProps.type === 'function' && !primitiveType) {
+            return getObjectMetadata(metadata, fieldProps.type, prefix);
+        }
+        if (Array.isArray(fieldProps.type)) {
+            const arrayPrimitiveType = (0, exports.getPrimitiveType)(fieldProps.type[0]);
+            let items;
+            if (arrayPrimitiveType) {
+                items = {
+                    type: arrayPrimitiveType,
+                    name: arrayPrimitiveType,
+                    destinationName: arrayPrimitiveType,
+                };
+            }
+            else {
+                if (typeof fieldProps.type[0] === 'function') {
+                    items = getObjectMetadata({
+                        name: 'Object',
+                        destinationName: 'Object',
+                    }, fieldProps.type[0], prefix);
+                }
+            }
+            return {
+                ...metadata,
+                type: 'Array',
+                items,
+            };
+        }
+    }
+    if (exports.primitiveTypeValues.has(type) ||
+        exports.primitiveTypeValues.has(primitiveType) ||
+        typeHasValue) {
+        return {
+            type: primitiveType || typeHasValue || type,
+            initialValue: typeHasValue ? fieldProps?.type : undefined,
+            ...metadata,
+        };
+    }
+    throw new Error(`unidentified type ${type} in ${destinationName} field`);
+};
+const createFieldDecorator = ({ prefix, enableInLambdaInvocation, getMetadata, }) => (props) => (target, destinationName) => {
+    if (!(0, build_env_utils_1.isBuildEnvironment)() && !enableInLambdaInvocation) {
+        return;
+    }
+    const filedKey = (0, exports.createFieldName)(prefix, field_types_1.FieldProperties.field);
+    const fields = (0, utils_1.getMetadataByKey)(target, filedKey) || [];
+    const propertyType = Reflect.getMetadata('design:type', target, destinationName).name;
+    const parentMetadata = getMetadata(props);
+    const metadata = [
+        ...fields,
+        {
+            ...parentMetadata,
+            ...getFieldMetadata({
+                destinationName,
+                type: propertyType,
+                fieldProps: {
+                    ...props,
+                    type: parentMetadata.forceType ?? props?.type,
+                },
+                prefix,
+            }),
+        },
+    ];
+    Reflect.defineMetadata(filedKey, metadata, target);
+};
+exports.createFieldDecorator = createFieldDecorator;
+const createFieldName = (prefix, type) => {
+    return `${prefix}:${type}`;
+};
+exports.createFieldName = createFieldName;

package/lib/decorators/field/field.types.d.ts

@@ -0,0 +1,71 @@
+import type { PayloadMetadata } from '../payload';
+export type BasicTypes = StringConstructor | NumberConstructor | BooleanConstructor;
+export type AllowedTypes = String | Number | Boolean | Function | [String | Number | Boolean | Function];
+export type AllowedTypesWithoutFunction = BasicTypes | [BasicTypes];
+export type EnumValue = (string | number)[];
+export interface FieldProps {
+    /**
+     * Original field name.
+     *
+     * Specifies the original name of the field as it is expected
+     * in the input or payload. This is used to map incoming data
+     * to the corresponding property in the system.
+     */
+    name?: string;
+    /**
+     * Field data type.
+     *
+     * Specifies the type of the field. By default, the type is inferred
+     * from the property that decorates the field. However, it can be
+     * explicitly set to a primitive type such as `String`, `Number`,
+     * `Boolean`, or to another payload type.
+     *
+     * This ensures correct parsing, validation, and serialization of the field's value.
+     */
+    type?: AllowedTypes;
+}
+export interface BaseFieldMetadata {
+    name: string;
+    destinationName: string;
+}
+export interface StringField extends BaseFieldMetadata {
+    type: 'String';
+    initialValue?: string;
+}
+export interface NumberField extends BaseFieldMetadata {
+    type: 'Number';
+    initialValue?: number;
+}
+export interface BooleanField extends BaseFieldMetadata {
+    type: 'Boolean';
+    initialValue?: boolean;
+}
+export interface ObjectField extends BaseFieldMetadata {
+    type: 'Object';
+    properties: FieldMetadata[];
+    payload: PayloadMetadata;
+}
+export interface ArrayField extends BaseFieldMetadata {
+    type: 'Array';
+    items: FieldMetadata;
+}
+export type FieldMetadata = StringField | NumberField | BooleanField | ObjectField | ArrayField;
+export type FieldTypes = FieldMetadata['type'];
+export type PrimitiveTypes = Extract<FieldTypes, 'String' | 'Number' | 'Boolean'>;
+export declare enum FieldProperties {
+    field = "lafken:field",
+    payload = "lafken:payload"
+}
+export interface CreateFieldDecoratorProps<P extends FieldProps, M> {
+    prefix: string;
+    enableInLambdaInvocation?: boolean;
+    getMetadata: (props?: P) => Omit<M, keyof FieldMetadata> & {
+        forceType?: any;
+    };
+}
+export interface GetFieldMetadataProps {
+    type: string;
+    prefix: string;
+    destinationName: string;
+    fieldProps?: FieldProps;
+}