@flipboxlabs/aws-audit-sdk 1.1.0

package/dist/schema/log.d.ts

@@ -0,0 +1,211 @@
+import * as z from "zod/v4";
+/**
+ * Audit operation status values.
+ *
+ * Used to indicate the outcome of an audited operation:
+ * - `SUCCESS`: Operation completed successfully
+ * - `WARN`: Operation completed with warnings
+ * - `FAIL`: Operation failed
+ * - `SKIP`: Operation was skipped
+ */
+export declare const Status: {
+    readonly SUCCESS: "success";
+    readonly WARN: "warn";
+    readonly FAIL: "fail";
+    readonly SKIP: "skip";
+};
+/**
+ * Union type of all valid status values.
+ */
+export type AnyStatus = (typeof Status)[keyof typeof Status];
+/**
+ * Schema for escalation tier values (1-3).
+ * @internal
+ */
+export declare const TierSchema: z.ZodNumber;
+/**
+ * Schema for audit status enum values.
+ * @internal
+ */
+export declare const StatusSchema: z.ZodEnum<{
+    success: "success";
+    warn: "warn";
+    fail: "fail";
+    skip: "skip";
+}>;
+/**
+ * Schema for application identifier values.
+ * Accepts any string; use config.schemas.app for strict validation.
+ * @internal
+ */
+export declare const AppSchema: z.ZodString;
+/**
+ * Schema for resource type values.
+ * Accepts any string; use config.schemas.resourceType for strict validation.
+ * @internal
+ */
+export declare const ResourceTypeSchema: z.ZodString;
+/**
+ * Schema for resource references (target/source).
+ *
+ * Identifies a resource within an application by app, type, and optional ID.
+ * @internal
+ */
+export declare const ResourceReferenceSchema: z.ZodObject<{
+    app: z.ZodString;
+    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    type: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Schema for additional related resources.
+ *
+ * Same structure as ResourceReferenceSchema, used for linking
+ * secondary resources to an audit entry.
+ * @internal
+ */
+export declare const AdditionalResourceSchema: z.ZodObject<{
+    app: z.ZodString;
+    type: z.ZodString;
+    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strip>;
+/**
+ * Recursive type for context values.
+ *
+ * Supports primitives (string, number, boolean) and nested objects
+ * for flexible metadata storage.
+ */
+type ContextValue = string | number | boolean | {
+    [key: string]: ContextValue;
+};
+/**
+ * Schema for the context object - a flexible key-value store.
+ * @internal
+ */
+export declare const ContextSchema: z.ZodRecord<z.ZodString, z.ZodType<ContextValue, unknown, z.core.$ZodTypeInternals<ContextValue, unknown>>>;
+/**
+ * Base schema for audit entries destined for CloudWatch Logs.
+ *
+ * @internal Use `createTypedLogAuditSchema` instead for type-safe validation
+ * with your config's app and resourceType enums.
+ *
+ * This schema accepts any string for app and resourceType values.
+ * For strict validation against configured values, use the factory function.
+ *
+ * **Transformations:**
+ * - `resources`: Set is converted to Array
+ * - `error`: Error instances are serialized to JSON strings
+ * - `tier`: Defaults to 2 (INFO) if not provided
+ * - `status`: Defaults to 'success' if not provided
+ */
+export declare const _BaseLogAuditSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    operation: z.ZodString;
+    tenantId: z.ZodOptional<z.ZodString>;
+    tier: z.ZodDefault<z.ZodNumber>;
+    status: z.ZodDefault<z.ZodEnum<{
+        success: "success";
+        warn: "warn";
+        fail: "fail";
+        skip: "skip";
+    }>>;
+    target: z.ZodObject<{
+        app: z.ZodString;
+        id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        type: z.ZodString;
+    }, z.core.$strip>;
+    source: z.ZodOptional<z.ZodObject<{
+        app: z.ZodString;
+        id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        type: z.ZodString;
+    }, z.core.$strip>>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<ContextValue, unknown, z.core.$ZodTypeInternals<ContextValue, unknown>>>>;
+    resources: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        app: z.ZodString;
+        type: z.ZodString;
+        id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    }, z.core.$strip>>, z.ZodSet<z.ZodObject<{
+        app: z.ZodString;
+        type: z.ZodString;
+        id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    }, z.core.$strip>>]>>, z.ZodTransform<{
+        app: string;
+        type: string;
+        id?: string | number | undefined;
+    }[] | undefined, Set<{
+        app: string;
+        type: string;
+        id?: string | number | undefined;
+    }> | {
+        app: string;
+        type: string;
+        id?: string | number | undefined;
+    }[] | undefined>>;
+    message: z.ZodOptional<z.ZodString>;
+    trace: z.ZodOptional<z.ZodString>;
+    event: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodString>;
+        "detail-type": z.ZodOptional<z.ZodString>;
+        detail: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>>, z.ZodTransform<string | undefined, string | Record<string, any> | undefined>>;
+    }, z.core.$strip>>;
+    error: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Error, Error>]>>, z.ZodTransform<string | undefined, string | Error | undefined>>;
+}, z.core.$strip>;
+/**
+ * Input type for log audit schemas.
+ *
+ * Use this type when building audit objects before validation.
+ * Accepts Error instances and Set for resources.
+ */
+export type LogAuditInput = z.input<typeof _BaseLogAuditSchema>;
+/**
+ * Creates a LogAuditSchema with typed app and resourceType schemas.
+ *
+ * Use this when you have a config with strict app/resourceType enums
+ * to get runtime validation against those specific values.
+ *
+ * @param resourceReferenceSchema - The typed resource reference schema from config.schemas.resourceReference
+ * @returns A LogAuditSchema that validates against the provided resource reference schema
+ *
+ * @example
+ * ```typescript
+ * const config = defineAuditConfig({
+ *   apps: ['Orders', 'Inventory'] as const,
+ *   resourceTypes: ['Order', 'Product'] as const,
+ * });
+ *
+ * const typedSchema = createTypedLogAuditSchema(config.schemas.resourceReference);
+ * typedSchema.parse({
+ *   operation: 'createOrder',
+ *   target: { app: 'Orders', type: 'Order', id: '123' },
+ * }); // Validates app/type against config
+ * ```
+ */
+export declare function createTypedLogAuditSchema<T extends z.ZodObject<{
+    app: z.ZodTypeAny;
+    type: z.ZodTypeAny;
+    id: z.ZodTypeAny;
+}>>(resourceReferenceSchema: T): z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    operation: z.ZodString;
+    tenantId: z.ZodOptional<z.ZodString>;
+    tier: z.ZodDefault<z.ZodNumber>;
+    status: z.ZodDefault<z.ZodEnum<{
+        success: "success";
+        warn: "warn";
+        fail: "fail";
+        skip: "skip";
+    }>>;
+    target: T;
+    source: z.ZodOptional<T>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<ContextValue, unknown, z.core.$ZodTypeInternals<ContextValue, unknown>>>>;
+    resources: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<T>, z.ZodSet<T>]>>, z.ZodTransform<z.core.output<T>[] | undefined, Set<z.core.output<T>> | z.core.output<T>[] | undefined>>;
+    message: z.ZodOptional<z.ZodString>;
+    trace: z.ZodOptional<z.ZodString>;
+    event: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodString>;
+        "detail-type": z.ZodOptional<z.ZodString>;
+        detail: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>>, z.ZodTransform<string | undefined, string | Record<string, any> | undefined>>;
+    }, z.core.$strip>>;
+    error: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodCustom<Error, Error>]>>, z.ZodTransform<string | undefined, string | Error | undefined>>;
+}, z.core.$strip>;
+export {};
+//# sourceMappingURL=log.d.ts.map

package/dist/schema/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../src/schema/log.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM;;;;;CAKT,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,MAAM,CAAC,CAAC,MAAM,OAAO,MAAM,CAAC,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,UAAU,aAAiC,CAAC;AAEzD;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;EAAgC,CAAC;AAE1D;;;;GAIG;AACH,eAAO,MAAM,SAAS,aAAa,CAAC;AAEpC;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,aAAa,CAAC;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;iBAOlC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB;;;;iBAEnC,CAAC;AAEH;;;;;GAKG;AACH,KAAK,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;CAAE,CAAC;AAehF;;;GAGG;AACH,eAAO,MAAM,aAAa,6GAA6C,CAAC;AAExE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuC9B,CAAC;AAEH;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,yBAAyB,CACxC,CAAC,SAAS,CAAC,CAAC,SAAS,CAAC;IACrB,GAAG,EAAE,CAAC,CAAC,UAAU,CAAC;IAClB,IAAI,EAAE,CAAC,CAAC,UAAU,CAAC;IACnB,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC;CACjB,CAAC,EACD,uBAAuB,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;kBA4B3B"}

package/dist/schema/log.js

@@ -0,0 +1,179 @@
+import * as z from "zod/v4";
+import { EventBridgeEventSchema } from "./model.js";
+/**
+ * Audit operation status values.
+ *
+ * Used to indicate the outcome of an audited operation:
+ * - `SUCCESS`: Operation completed successfully
+ * - `WARN`: Operation completed with warnings
+ * - `FAIL`: Operation failed
+ * - `SKIP`: Operation was skipped
+ */
+export const Status = {
+    SUCCESS: "success",
+    WARN: "warn",
+    FAIL: "fail",
+    SKIP: "skip",
+};
+/**
+ * Schema for escalation tier values (1-3).
+ * @internal
+ */
+export const TierSchema = z.number().int().gte(1).lte(3);
+/**
+ * Schema for audit status enum values.
+ * @internal
+ */
+export const StatusSchema = z.enum(Object.values(Status));
+/**
+ * Schema for application identifier values.
+ * Accepts any string; use config.schemas.app for strict validation.
+ * @internal
+ */
+export const AppSchema = z.string();
+/**
+ * Schema for resource type values.
+ * Accepts any string; use config.schemas.resourceType for strict validation.
+ * @internal
+ */
+export const ResourceTypeSchema = z.string();
+/**
+ * Schema for resource references (target/source).
+ *
+ * Identifies a resource within an application by app, type, and optional ID.
+ * @internal
+ */
+export const ResourceReferenceSchema = z.object({
+    /** Application that owns this resource */
+    app: AppSchema,
+    /** Unique identifier within the resource type (optional) */
+    id: z.union([z.string(), z.number()]).optional(),
+    /** Type/category of the resource */
+    type: ResourceTypeSchema,
+});
+/**
+ * Schema for additional related resources.
+ *
+ * Same structure as ResourceReferenceSchema, used for linking
+ * secondary resources to an audit entry.
+ * @internal
+ */
+export const AdditionalResourceSchema = ResourceReferenceSchema.extend({
+    id: z.union([z.string(), z.number()]).optional(),
+});
+/**
+ * Schema for recursive context values.
+ *
+ * Validates nested key-value structures for audit metadata.
+ * @internal
+ */
+const recursiveValueSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.lazy(() => z.record(z.string(), recursiveValueSchema)),
+]);
+/**
+ * Schema for the context object - a flexible key-value store.
+ * @internal
+ */
+export const ContextSchema = z.record(z.string(), recursiveValueSchema);
+/**
+ * Base schema for audit entries destined for CloudWatch Logs.
+ *
+ * @internal Use `createTypedLogAuditSchema` instead for type-safe validation
+ * with your config's app and resourceType enums.
+ *
+ * This schema accepts any string for app and resourceType values.
+ * For strict validation against configured values, use the factory function.
+ *
+ * **Transformations:**
+ * - `resources`: Set is converted to Array
+ * - `error`: Error instances are serialized to JSON strings
+ * - `tier`: Defaults to 2 (INFO) if not provided
+ * - `status`: Defaults to 'success' if not provided
+ */
+export const _BaseLogAuditSchema = z.object({
+    /** Optional audit ID for retry correlation. If provided, retries with the same ID are correlated. */
+    id: z.string().optional(),
+    /** Name of the operation being audited (required) */
+    operation: z.string(),
+    /** Tenant identifier for multi-tenancy support (optional) */
+    tenantId: z.string().optional(),
+    /** Escalation tier for visibility (1=internal, 2=info, 3=public). Defaults to 2. */
+    tier: TierSchema.default(2),
+    /** Outcome status of the operation. Defaults to 'success'. */
+    status: StatusSchema.default(Status.SUCCESS),
+    /** The primary resource being audited (required) */
+    target: ResourceReferenceSchema,
+    /** The resource that initiated the operation (optional) */
+    source: ResourceReferenceSchema.optional(),
+    /** Additional metadata as key-value pairs (optional) */
+    context: ContextSchema.optional(),
+    /** Additional resources affected by this operation. Set is converted to Array. */
+    resources: z
+        .union([z.array(AdditionalResourceSchema), z.set(AdditionalResourceSchema)])
+        .optional()
+        .pipe(z.transform((val) => (val instanceof Set ? Array.from(val) : val))),
+    /** Human-readable description of the audit (optional) */
+    message: z.string().optional(),
+    /** Trace identifier for distributed tracing (optional) */
+    trace: z.string().optional(),
+    /** Original EventBridge event that triggered this audit (optional) */
+    event: EventBridgeEventSchema.optional(),
+    /** Error details if the operation failed. Error instances are JSON serialized. */
+    error: z
+        .union([z.string(), z.instanceof(Error)])
+        .optional()
+        .pipe(z.transform((e) => e instanceof Error
+        ? JSON.stringify(e, Object.getOwnPropertyNames(e))
+        : e)),
+});
+/**
+ * Creates a LogAuditSchema with typed app and resourceType schemas.
+ *
+ * Use this when you have a config with strict app/resourceType enums
+ * to get runtime validation against those specific values.
+ *
+ * @param resourceReferenceSchema - The typed resource reference schema from config.schemas.resourceReference
+ * @returns A LogAuditSchema that validates against the provided resource reference schema
+ *
+ * @example
+ * ```typescript
+ * const config = defineAuditConfig({
+ *   apps: ['Orders', 'Inventory'] as const,
+ *   resourceTypes: ['Order', 'Product'] as const,
+ * });
+ *
+ * const typedSchema = createTypedLogAuditSchema(config.schemas.resourceReference);
+ * typedSchema.parse({
+ *   operation: 'createOrder',
+ *   target: { app: 'Orders', type: 'Order', id: '123' },
+ * }); // Validates app/type against config
+ * ```
+ */
+export function createTypedLogAuditSchema(resourceReferenceSchema) {
+    return z.object({
+        id: z.string().optional(),
+        operation: z.string(),
+        tenantId: z.string().optional(),
+        tier: TierSchema.default(2),
+        status: StatusSchema.default(Status.SUCCESS),
+        target: resourceReferenceSchema,
+        source: resourceReferenceSchema.optional(),
+        context: ContextSchema.optional(),
+        resources: z
+            .union([z.array(resourceReferenceSchema), z.set(resourceReferenceSchema)])
+            .optional()
+            .pipe(z.transform((val) => (val instanceof Set ? Array.from(val) : val))),
+        message: z.string().optional(),
+        trace: z.string().optional(),
+        event: EventBridgeEventSchema.optional(),
+        error: z
+            .union([z.string(), z.instanceof(Error)])
+            .optional()
+            .pipe(z.transform((e) => e instanceof Error
+            ? JSON.stringify(e, Object.getOwnPropertyNames(e))
+            : e)),
+    });
+}

package/dist/schema/model.d.ts

@@ -0,0 +1,110 @@
+import * as z from "zod/v4";
+/**
+ * Schema for EventBridge event data embedded in audit records.
+ *
+ * Captures the essential fields from an EventBridge event for replay
+ * and debugging purposes. The detail field is automatically serialized
+ * to a JSON string if provided as an object.
+ *
+ * @example
+ * ```typescript
+ * const event = EventBridgeEventSchema.parse({
+ *   source: 'orders.service',
+ *   'detail-type': 'OrderCreated',
+ *   detail: { orderId: '123', amount: 99.99 },
+ * });
+ * // event.detail is now '{"orderId":"123","amount":99.99}'
+ * ```
+ */
+export declare const EventBridgeEventSchema: z.ZodObject<{
+    source: z.ZodOptional<z.ZodString>;
+    "detail-type": z.ZodOptional<z.ZodString>;
+    detail: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>]>>, z.ZodTransform<string | undefined, string | Record<string, any> | undefined>>;
+}, z.core.$strip>;
+/**
+ * Inferred output type from EventBridgeEventSchema.
+ * Note: detail is always a string after transformation.
+ */
+export type EventBridgeEvent = z.output<typeof EventBridgeEventSchema>;
+/**
+ * Schema for pagination parameters in list queries.
+ *
+ * Used to control page size and cursor-based pagination
+ * for DynamoDB query operations.
+ *
+ * @example
+ * ```typescript
+ * const pagination = PaginationSchema.parse({
+ *   pageSize: 25,
+ *   nextToken: 'abc123...',
+ * });
+ * ```
+ */
+export declare const PaginationSchema: z.ZodObject<{
+    pageSize: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    nextToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Inferred output type from PaginationSchema.
+ */
+export type Pagination = z.output<typeof PaginationSchema>;
+/**
+ * Factory function to create a collection schema with a specific item type.
+ *
+ * @param itemSchema - Zod schema for the collection items
+ * @returns A schema that validates an object with an `items` array
+ *
+ * @example
+ * ```typescript
+ * const UserCollectionSchema = CollectionSchema(UserSchema);
+ * const result = UserCollectionSchema.parse({ items: [user1, user2] });
+ * ```
+ */
+export declare const CollectionSchema: <T extends z.ZodTypeAny>(itemSchema: T) => z.ZodObject<{
+    items: z.ZodArray<T>;
+}, z.core.$strip>;
+/**
+ * Generic collection type containing an array of items.
+ *
+ * @typeParam I - The type of items in the collection
+ */
+export type Collection<I> = {
+    items: I[];
+};
+/**
+ * Factory function to create a paginated collection schema.
+ *
+ * Extends the basic collection with optional pagination metadata
+ * for cursor-based pagination support.
+ *
+ * @param itemSchema - Zod schema for the collection items
+ * @returns A schema that validates items array with optional pagination
+ *
+ * @example
+ * ```typescript
+ * const PaginatedAuditsSchema = PaginationCollectionSchema(AuditSchema);
+ * const result = PaginatedAuditsSchema.parse({
+ *   items: [audit1, audit2],
+ *   pagination: { nextToken: 'xyz789' },
+ * });
+ * ```
+ */
+export declare const PaginationCollectionSchema: <T extends z.ZodTypeAny>(itemSchema: T) => z.ZodObject<{
+    items: z.ZodArray<T>;
+    pagination: z.ZodOptional<z.ZodObject<{
+        pageSize: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        nextToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Generic paginated collection type.
+ *
+ * Extends Collection with optional pagination metadata for
+ * cursor-based navigation through large result sets.
+ *
+ * @typeParam I - The type of items in the collection
+ */
+export type PaginationCollection<I> = Collection<I> & {
+    pagination?: Pagination;
+};
+//# sourceMappingURL=model.d.ts.map

package/dist/schema/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/schema/model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,sBAAsB;;;;iBAcjC,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEvE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB;;;iBAK3B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE3D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,YAAY,CAAC;;iBAGnE,CAAC;AAEJ;;;;GAIG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC3B,KAAK,EAAE,CAAC,EAAE,CAAC;CACX,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,0BAA0B,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAChE,YAAY,CAAC;;;;;;iBAKX,CAAC;AAEJ;;;;;;;GAOG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG;IACrD,UAAU,CAAC,EAAE,UAAU,CAAC;CACxB,CAAC"}

package/dist/schema/model.js

@@ -0,0 +1,86 @@
+import * as z from "zod/v4";
+/**
+ * Schema for EventBridge event data embedded in audit records.
+ *
+ * Captures the essential fields from an EventBridge event for replay
+ * and debugging purposes. The detail field is automatically serialized
+ * to a JSON string if provided as an object.
+ *
+ * @example
+ * ```typescript
+ * const event = EventBridgeEventSchema.parse({
+ *   source: 'orders.service',
+ *   'detail-type': 'OrderCreated',
+ *   detail: { orderId: '123', amount: 99.99 },
+ * });
+ * // event.detail is now '{"orderId":"123","amount":99.99}'
+ * ```
+ */
+export const EventBridgeEventSchema = z.object({
+    /** The source service that generated the event */
+    source: z.string().optional(),
+    /** The type/category of the event */
+    "detail-type": z.string().optional(),
+    /** Event payload - objects are automatically JSON stringified */
+    detail: z
+        .union([z.string(), z.record(z.string(), z.any())])
+        .optional()
+        .pipe(z.transform((val) => typeof val === "object" ? JSON.stringify(val) : val)),
+});
+/**
+ * Schema for pagination parameters in list queries.
+ *
+ * Used to control page size and cursor-based pagination
+ * for DynamoDB query operations.
+ *
+ * @example
+ * ```typescript
+ * const pagination = PaginationSchema.parse({
+ *   pageSize: 25,
+ *   nextToken: 'abc123...',
+ * });
+ * ```
+ */
+export const PaginationSchema = z.object({
+    /** Number of items per page (string or number accepted) */
+    pageSize: z.union([z.string(), z.number()]).nullable().optional(),
+    /** Cursor token for fetching the next page */
+    nextToken: z.string().nullable().optional(),
+});
+/**
+ * Factory function to create a collection schema with a specific item type.
+ *
+ * @param itemSchema - Zod schema for the collection items
+ * @returns A schema that validates an object with an `items` array
+ *
+ * @example
+ * ```typescript
+ * const UserCollectionSchema = CollectionSchema(UserSchema);
+ * const result = UserCollectionSchema.parse({ items: [user1, user2] });
+ * ```
+ */
+export const CollectionSchema = (itemSchema) => z.object({
+    items: z.array(itemSchema),
+});
+/**
+ * Factory function to create a paginated collection schema.
+ *
+ * Extends the basic collection with optional pagination metadata
+ * for cursor-based pagination support.
+ *
+ * @param itemSchema - Zod schema for the collection items
+ * @returns A schema that validates items array with optional pagination
+ *
+ * @example
+ * ```typescript
+ * const PaginatedAuditsSchema = PaginationCollectionSchema(AuditSchema);
+ * const result = PaginatedAuditsSchema.parse({
+ *   items: [audit1, audit2],
+ *   pagination: { nextToken: 'xyz789' },
+ * });
+ * ```
+ */
+export const PaginationCollectionSchema = (itemSchema) => z.object({
+    items: z.array(itemSchema),
+    pagination: PaginationSchema.optional(),
+});