@awsless/awsless 0.0.655 → 0.0.657

package/dist/build-json-schema.js

@@ -4,7 +4,7 @@ import { join as join2 } from "node:path";
 import { zodToJsonSchema } from "zod-to-json-schema";
 
 // src/config/app.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 
 // src/feature/alert/schema.ts
 import { kebabCase } from "change-case";
@@ -201,9 +201,6 @@ var EphemeralStorageSizeSchema = SizeSchema.refine(
 var ReservedConcurrentExecutionsSchema = z11.number().int().min(0).describe("The number of simultaneous executions to reserve for the function. You can specify a number from 0.");
 var EnvironmentSchema = z11.record(z11.string(), z11.string()).optional().describe("Environment variable key-value pairs.");
 var ArchitectureSchema = z11.enum(["x86_64", "arm64"]).describe("The instruction set architecture that the function supports.");
-var RetryAttemptsSchema = z11.number().int().min(0).max(2).describe(
-  "The maximum number of times to retry when the function returns an error. You can specify a number from 0 to 2."
-);
 var NodeRuntimeSchema = z11.enum(["nodejs18.x", "nodejs20.x", "nodejs22.x", "nodejs24.x"]);
 var ContainerRuntimeSchema = z11.literal("container");
 var RuntimeSchema = NodeRuntimeSchema.or(ContainerRuntimeSchema).or(z11.string()).describe("The identifier of the function's runtime.");
@@ -296,7 +293,7 @@ var FnSchema = z11.object({
   memorySize: MemorySizeSchema.optional(),
   architecture: ArchitectureSchema.optional(),
   ephemeralStorageSize: EphemeralStorageSizeSchema.optional(),
-  retryAttempts: RetryAttemptsSchema.optional(),
+  // retryAttempts: RetryAttemptsSchema.optional(),
   reserved: ReservedConcurrentExecutionsSchema.optional(),
   layers: LayersSchema.optional(),
   environment: EnvironmentSchema.optional(),
@@ -330,7 +327,7 @@ var FunctionDefaultSchema = z11.object({
   memorySize: MemorySizeSchema.default("128 MB"),
   architecture: ArchitectureSchema.default("arm64"),
   ephemeralStorageSize: EphemeralStorageSizeSchema.default("512 MB"),
-  retryAttempts: RetryAttemptsSchema.default(2),
+  // retryAttempts: RetryAttemptsSchema.default(2),
   reserved: ReservedConcurrentExecutionsSchema.optional(),
   layers: LayersSchema.optional(),
   environment: EnvironmentSchema.optional(),
@@ -372,10 +369,16 @@ var NotifySchema = z14.union([
   EmailSchema.transform((v) => [v]),
   EmailSchema.array()
 ]).describe("Receive an email notification when consuming failure entries goes wrong.");
-var OnFailureDefaultSchema = z14.object({
-  consumer: FunctionSchema,
-  notify: NotifySchema.optional()
-}).optional().describe(
+var OnFailureDefaultSchema = z14.union([
+  FunctionSchema.transform((consumer) => ({
+    consumer,
+    notify: []
+  })),
+  z14.object({
+    consumer: FunctionSchema,
+    notify: NotifySchema.optional()
+  })
+]).optional().describe(
   [
     "Defining a onFailure handler will add a global onFailure handler for the following resources:",
     "- Tasks",
@@ -425,12 +428,16 @@ var PubSubDefaultSchema = z16.record(
     // 	.optional(),
   })
 ).optional().describe("Define the pubsub subscriber in your stack.");
+var RetryAttemptsSchema = z16.number().int().min(0).max(2).describe(
+  "The maximum number of times to retry when the function returns an error. You can specify a number from 0 to 2."
+);
 var PubSubSchema = z16.record(
   ResourceIdSchema,
   z16.object({
     sql: z16.string().describe("The SQL statement used to query the IOT topic."),
     sqlVersion: z16.enum(["2015-10-08", "2016-03-23", "beta"]).default("2016-03-23").describe("The version of the SQL rules engine to use when evaluating the rule."),
-    consumer: FunctionSchema.describe("The consuming lambda function properties.")
+    consumer: FunctionSchema.describe("The consuming lambda function properties."),
+    retryAttempts: RetryAttemptsSchema.default(2)
   })
 ).optional().describe("Define the pubsub subscriber in your stack.");
 
@@ -897,15 +904,34 @@ var InstanceDefaultSchema = z22.object({
 
 // src/feature/topic/schema.ts
 import { kebabCase as kebabCase3 } from "change-case";
+import { z as z24 } from "zod";
+
+// src/feature/task/schema.ts
 import { z as z23 } from "zod";
-var TopicNameSchema = z23.string().min(3).max(256).regex(/^[a-z0-9\-]+$/i, "Invalid topic name").transform((value) => kebabCase3(value)).describe("Define event topic name.");
-var TopicsDefaultSchema = z23.array(TopicNameSchema).refine((topics) => {
+var RetryAttemptsSchema3 = z23.number().int().min(0).max(2).describe(
+  "The maximum number of times to retry when the function returns an error. You can specify a number from 0 to 2."
+);
+var TaskSchema = z23.union([
+  FunctionSchema.transform((consumer) => ({
+    consumer,
+    retryAttempts: 2
+  })),
+  z23.object({
+    consumer: FunctionSchema,
+    retryAttempts: RetryAttemptsSchema3.default(2)
+  })
+]);
+var TasksSchema = z23.record(ResourceIdSchema, TaskSchema).optional().describe("Define the tasks in your stack.");
+
+// src/feature/topic/schema.ts
+var TopicNameSchema = z24.string().min(3).max(256).regex(/^[a-z0-9\-]+$/i, "Invalid topic name").transform((value) => kebabCase3(value)).describe("Define event topic name.");
+var TopicsDefaultSchema = z24.array(TopicNameSchema).refine((topics) => {
   return topics.length === new Set(topics).size;
 }, "Must be a list of unique topic names").optional().describe("Define the event topics for your app.");
-var SubscribersSchema = z23.record(TopicNameSchema, FunctionSchema).optional().describe("Define the event topics to subscribe too in your stack.");
+var SubscribersSchema = z24.record(TopicNameSchema, TaskSchema).optional().describe("Define the event topics to subscribe too in your stack.");
 
 // src/config/schema/region.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var US = ["us-east-2", "us-east-1", "us-west-1", "us-west-2"];
 var AF = ["af-south-1"];
 var AP = [
@@ -934,16 +960,16 @@ var EU = [
 var ME = ["me-south-1", "me-central-1"];
 var SA = ["sa-east-1"];
 var regions = [...US, ...AF, ...AP, ...CA, ...EU, ...ME, ...SA];
-var RegionSchema = z24.enum(regions);
+var RegionSchema = z25.enum(regions);
 
 // src/config/app.ts
-var AppSchema = z25.object({
-  $schema: z25.string().optional(),
+var AppSchema = z26.object({
+  $schema: z26.string().optional(),
   name: ResourceIdSchema.describe("App name."),
   region: RegionSchema.describe("The AWS region to deploy to."),
-  profile: z25.string().describe("The AWS profile to deploy to."),
-  protect: z25.boolean().default(false).describe("Protect your app & stacks from being deleted."),
-  removal: z25.enum(["remove", "retain"]).default("remove").describe(
+  profile: z26.string().describe("The AWS profile to deploy to."),
+  protect: z26.boolean().default(false).describe("Protect your app & stacks from being deleted."),
+  removal: z26.enum(["remove", "retain"]).default("remove").describe(
     [
       "Configure how your resources are handled when they have to be removed.",
       "",
@@ -957,7 +983,7 @@ var AppSchema = z25.object({
   // 	.default('prod')
   // 	.describe('The deployment stage.'),
   // onFailure: OnFailureSchema,
-  defaults: z25.object({
+  defaults: z26.object({
     onFailure: OnFailureDefaultSchema,
     onLog: OnLogDefaultSchema,
     auth: AuthDefaultSchema,
@@ -1238,7 +1264,7 @@ import { z as z41 } from "zod";
 
 // src/feature/cache/schema.ts
 import { gibibytes as gibibytes2 } from "@awsless/size";
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var StorageSchema = SizeSchema.refine(sizeMin(gibibytes2(1)), "Minimum storage size is 1 GB").refine(
   sizeMax(gibibytes2(5e3)),
   "Maximum storage size is 5000 GB"
@@ -1249,31 +1275,31 @@ var MinimumStorageSchema = StorageSchema.describe(
 var MaximumStorageSchema = StorageSchema.describe(
   "The upper limit for data storage the cache is set to use. You can specify a size value from 1 GB to 5000 GB."
 );
-var EcpuSchema = z26.number().int().min(1e3).max(15e6);
+var EcpuSchema = z27.number().int().min(1e3).max(15e6);
 var MinimumEcpuSchema = EcpuSchema.describe(
   "The minimum number of ECPUs the cache can consume per second. You can specify a integer from 1,000 to 15,000,000."
 );
 var MaximumEcpuSchema = EcpuSchema.describe(
   "The maximum number of ECPUs the cache can consume per second. You can specify a integer from 1,000 to 15,000,000."
 );
-var CachesSchema = z26.record(
+var CachesSchema = z27.record(
   ResourceIdSchema,
-  z26.object({
+  z27.object({
     minStorage: MinimumStorageSchema.optional(),
     maxStorage: MaximumStorageSchema.optional(),
     minECPU: MinimumEcpuSchema.optional(),
     maxECPU: MaximumEcpuSchema.optional(),
-    snapshotRetentionLimit: z26.number().int().positive().default(1)
+    snapshotRetentionLimit: z27.number().int().positive().default(1)
   })
 ).optional().describe("Define the caches in your stack. For access to the cache put your functions inside the global VPC.");
 
 // src/feature/command/schema.ts
-import { z as z27 } from "zod";
-var CommandSchema = z27.union([
-  z27.object({
+import { z as z28 } from "zod";
+var CommandSchema = z28.union([
+  z28.object({
     file: LocalFileSchema,
-    handler: z27.string().default("default").describe("The name of the handler that needs to run"),
-    description: z27.string().optional().describe("A description of the command")
+    handler: z28.string().default("default").describe("The name of the handler that needs to run"),
+    description: z28.string().optional().describe("A description of the command")
     // options: z.record(ResourceIdSchema, OptionSchema).optional(),
     // arguments: z.record(ResourceIdSchema, ArgumentSchema).optional(),
   }),
@@ -1283,22 +1309,22 @@ var CommandSchema = z27.union([
     description: void 0
   }))
 ]);
-var CommandsSchema = z27.record(ResourceIdSchema, CommandSchema).optional().describe("Define the custom commands for your stack.");
+var CommandsSchema = z28.record(ResourceIdSchema, CommandSchema).optional().describe("Define the custom commands for your stack.");
 
 // src/feature/config/schema.ts
-import { z as z28 } from "zod";
-var ConfigNameSchema = z28.string().regex(/[a-z0-9\-]/g, "Invalid config name");
-var ConfigsSchema = z28.array(ConfigNameSchema).optional().describe("Define the config values for your stack.");
+import { z as z29 } from "zod";
+var ConfigNameSchema = z29.string().regex(/[a-z0-9\-]/g, "Invalid config name");
+var ConfigsSchema = z29.array(ConfigNameSchema).optional().describe("Define the config values for your stack.");
 
 // src/feature/cron/schema/index.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 
 // src/feature/cron/schema/schedule.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 import { awsCronExpressionValidator } from "aws-cron-expression-validator";
-var RateExpressionSchema = z29.custom(
+var RateExpressionSchema = z30.custom(
   (value) => {
-    return z29.string().regex(/^[0-9]+ (seconds?|minutes?|hours?|days?)$/).refine((rate) => {
+    return z30.string().regex(/^[0-9]+ (seconds?|minutes?|hours?|days?)$/).refine((rate) => {
       const [str] = rate.split(" ");
       const number = parseInt(str);
       return number > 0;
@@ -1314,9 +1340,9 @@ var RateExpressionSchema = z29.custom(
   }
   return `rate(${rate})`;
 });
-var CronExpressionSchema = z29.custom(
+var CronExpressionSchema = z30.custom(
   (value) => {
-    return z29.string().safeParse(value).success;
+    return z30.string().safeParse(value).success;
   },
   { message: "Invalid cron expression" }
 ).superRefine((value, ctx) => {
@@ -1325,12 +1351,12 @@ var CronExpressionSchema = z29.custom(
   } catch (error) {
     if (error instanceof Error) {
       ctx.addIssue({
-        code: z29.ZodIssueCode.custom,
+        code: z30.ZodIssueCode.custom,
         message: `Invalid cron expression: ${error.message}`
       });
     } else {
       ctx.addIssue({
-        code: z29.ZodIssueCode.custom,
+        code: z30.ZodIssueCode.custom,
         message: "Invalid cron expression"
       });
     }
@@ -1341,28 +1367,32 @@ var CronExpressionSchema = z29.custom(
 var ScheduleExpressionSchema = RateExpressionSchema.or(CronExpressionSchema);
 
 // src/feature/cron/schema/index.ts
-var CronsSchema = z30.record(
+var RetryAttemptsSchema4 = z31.number().int().min(0).max(2).describe(
+  "The maximum number of times to retry when the function returns an error. You can specify a number from 0 to 2."
+);
+var CronsSchema = z31.record(
   ResourceIdSchema,
-  z30.object({
-    enabled: z30.boolean().default(true).describe("If the cron is enabled."),
+  z31.object({
+    enabled: z31.boolean().default(true).describe("If the cron is enabled."),
     consumer: FunctionSchema.describe("The consuming lambda function properties."),
     schedule: ScheduleExpressionSchema.describe(
       'The scheduling expression.\n\nexample: "0 20 * * ? *"\nexample: "5 minutes"'
     ),
-    payload: z30.unknown().optional().describe("The JSON payload that will be passed to the consumer.")
+    payload: z31.unknown().optional().describe("The JSON payload that will be passed to the consumer."),
+    retryAttempts: RetryAttemptsSchema4.default(2)
   })
 ).optional().describe(`Define the cron jobs in your stack.`);
 
 // src/feature/search/schema.ts
 import { gibibytes as gibibytes3 } from "@awsless/size";
-import { z as z31 } from "zod";
-var VersionSchema = z31.union([
+import { z as z32 } from "zod";
+var VersionSchema = z32.union([
   //
-  z31.enum(["2.13", "2.11", "2.9", "2.7", "2.5", "2.3", "1.3"]),
-  z31.string()
+  z32.enum(["2.13", "2.11", "2.9", "2.7", "2.5", "2.3", "1.3"]),
+  z32.string()
 ]).describe("Specify the OpenSearch engine version.");
-var TypeSchema = z31.union([
-  z31.enum([
+var TypeSchema = z32.union([
+  z32.enum([
     "t3.small",
     "t3.medium",
     "m3.medium",
@@ -1436,13 +1466,13 @@ var TypeSchema = z31.union([
     "r6gd.12xlarge",
     "r6gd.16xlarge"
   ]),
-  z31.string()
+  z32.string()
 ]).describe("Instance type of data nodes in the cluster.");
-var CountSchema = z31.number().int().min(1).describe("Number of instances in the cluster.");
+var CountSchema = z32.number().int().min(1).describe("Number of instances in the cluster.");
 var StorageSizeSchema = SizeSchema.refine(sizeMin(gibibytes3(10)), "Minimum storage size is 10 GB").refine(sizeMax(gibibytes3(100)), "Maximum storage size is 100 GB").describe("The size of the function's /tmp directory. You can specify a size value from 512 MB to 10 GiB.");
-var SearchsSchema = z31.record(
+var SearchsSchema = z32.record(
   ResourceIdSchema,
-  z31.object({
+  z32.object({
     type: TypeSchema.default("t3.small"),
     count: CountSchema.default(1),
     version: VersionSchema.default("2.13"),
@@ -1453,12 +1483,12 @@ var SearchsSchema = z31.record(
 ).optional().describe("Define the search instances in your stack. Backed by OpenSearch.");
 
 // src/feature/site/schema.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 
 // src/config/schema/local-entry.ts
 import { stat as stat3 } from "fs/promises";
-import { z as z32 } from "zod";
-var LocalEntrySchema = z32.union([
+import { z as z33 } from "zod";
+var LocalEntrySchema = z33.union([
   RelativePathSchema.refine(async (path) => {
     try {
       const s = await stat3(path);
@@ -1467,7 +1497,7 @@ var LocalEntrySchema = z32.union([
       return false;
     }
   }, `File or directory doesn't exist`),
-  z32.object({
+  z33.object({
     nocheck: RelativePathSchema.describe(
       "Specifies a local file or directory without checking if the file or directory exists."
     )
@@ -1475,21 +1505,21 @@ var LocalEntrySchema = z32.union([
 ]);
 
 // src/feature/site/schema.ts
-var SitesSchema = z33.record(
+var SitesSchema = z34.record(
   ResourceIdSchema,
-  z33.object({
+  z34.object({
     router: ResourceIdSchema.describe("The router id to link your site with."),
     path: RouteSchema2.describe("The path inside the router to link your site to."),
-    build: z33.object({
-      command: z33.string().describe(
+    build: z34.object({
+      command: z34.string().describe(
         `Specifies the files and directories to generate the cache key for your custom build command.`
       ),
-      cacheKey: z33.union([LocalEntrySchema.transform((v) => [v]), LocalEntrySchema.array()]).describe(
+      cacheKey: z34.union([LocalEntrySchema.transform((v) => [v]), LocalEntrySchema.array()]).describe(
         `Specifies the files and directories to generate the cache key for your custom build command.`
       ),
-      configs: z33.string().array().optional().describe("Define the config values for your build command.")
+      configs: z34.string().array().optional().describe("Define the config values for your build command.")
     }).optional().describe(`Specifies the build process for sites that need a build step.`),
-    static: z33.union([LocalDirectorySchema, z33.boolean()]).optional().describe(
+    static: z34.union([LocalDirectorySchema, z34.boolean()]).optional().describe(
       "Specifies the path to the static files directory. Additionally you can also pass `true` when you don't have local static files, but still want to make an S3 bucket."
     ),
     ssr: FunctionSchema.optional().describe("Specifies the file that will render the site on the server.")
@@ -1497,45 +1527,45 @@ var SitesSchema = z33.record(
 ).optional().describe("Define the sites in your stack.");
 
 // src/feature/store/schema.ts
-import { z as z34 } from "zod";
-var StoresSchema = z34.union([
-  z34.array(ResourceIdSchema).transform((list) => {
+import { z as z35 } from "zod";
+var StoresSchema = z35.union([
+  z35.array(ResourceIdSchema).transform((list) => {
     const stores = {};
     for (const key of list) {
       stores[key] = {};
     }
     return stores;
   }),
-  z34.record(
+  z35.record(
     ResourceIdSchema,
-    z34.object({
+    z35.object({
       static: LocalDirectorySchema.optional().describe("Specifies the path to the static files directory."),
-      versioning: z34.boolean().default(false).describe("Enable versioning of your store."),
-      events: z34.object({
+      versioning: z35.boolean().default(false).describe("Enable versioning of your store."),
+      events: z35.object({
         // create
-        "created:*": FunctionSchema.optional().describe(
+        "created:*": TaskSchema.optional().describe(
           "Subscribe to notifications regardless of the API that was used to create an object."
         ),
-        "created:put": FunctionSchema.optional().describe(
+        "created:put": TaskSchema.optional().describe(
           "Subscribe to notifications when an object is created using the PUT API operation."
         ),
-        "created:post": FunctionSchema.optional().describe(
+        "created:post": TaskSchema.optional().describe(
           "Subscribe to notifications when an object is created using the POST API operation."
         ),
-        "created:copy": FunctionSchema.optional().describe(
+        "created:copy": TaskSchema.optional().describe(
           "Subscribe to notifications when an object is created using the COPY API operation."
         ),
-        "created:upload": FunctionSchema.optional().describe(
+        "created:upload": TaskSchema.optional().describe(
           "Subscribe to notifications when an object multipart upload has been completed."
         ),
         // remove
-        "removed:*": FunctionSchema.optional().describe(
+        "removed:*": TaskSchema.optional().describe(
           "Subscribe to notifications when an object is deleted or a delete marker for a versioned object is created."
         ),
-        "removed:delete": FunctionSchema.optional().describe(
+        "removed:delete": TaskSchema.optional().describe(
           "Subscribe to notifications when an object is deleted"
         ),
-        "removed:marker": FunctionSchema.optional().describe(
+        "removed:marker": TaskSchema.optional().describe(
           "Subscribe to notifications when a delete marker for a versioned object is created."
         )
       }).optional().describe("Describes the store events you want to subscribe too.")
@@ -1544,30 +1574,30 @@ var StoresSchema = z34.union([
 ]).optional().describe("Define the stores in your stack.");
 
 // src/feature/icon/schema.ts
-import { z as z35 } from "zod";
+import { z as z36 } from "zod";
 var staticOriginSchema = LocalDirectorySchema.describe(
   "Specifies the path to a local image directory that will be uploaded in S3."
 );
 var functionOriginSchema = FunctionSchema.describe(
   "Specifies the file that will be called when an image isn't found in the (cache) bucket."
 );
-var IconsSchema = z35.record(
+var IconsSchema = z36.record(
   ResourceIdSchema,
-  z35.object({
+  z36.object({
     // domain: ResourceIdSchema.describe('The domain id to link your site with.').optional(),
     // subDomain: z.string().optional(),
     router: ResourceIdSchema.describe("The router id to link your icon proxy."),
     path: RouteSchema2.describe("The path inside the router to link your icon proxy to."),
     log: LogSchema.optional(),
     cacheDuration: DurationSchema.optional().describe("The cache duration of the cached icons."),
-    preserveIds: z35.boolean().optional().default(false).describe("Preserve the IDs of the icons."),
-    symbols: z35.boolean().optional().default(false).describe(`Convert the SVG's to SVG symbols.`),
-    origin: z35.union([
-      z35.object({
+    preserveIds: z36.boolean().optional().default(false).describe("Preserve the IDs of the icons."),
+    symbols: z36.boolean().optional().default(false).describe(`Convert the SVG's to SVG symbols.`),
+    origin: z36.union([
+      z36.object({
         static: staticOriginSchema,
         function: functionOriginSchema.optional()
       }),
-      z35.object({
+      z36.object({
         static: staticOriginSchema.optional(),
         function: functionOriginSchema
       })
@@ -1594,13 +1624,13 @@ var IconsSchema = z35.record(
 ).optional().describe("Define an svg icon proxy in your stack. Store, optimize, and deliver svg icons at scale.");
 
 // src/feature/image/schema.ts
-import { z as z36 } from "zod";
-var transformationOptionsSchema = z36.object({
-  width: z36.number().int().positive().optional(),
-  height: z36.number().int().positive().optional(),
-  fit: z36.enum(["cover", "contain", "fill", "inside", "outside"]).optional(),
-  position: z36.enum(["top", "right top", "right", "right bottom", "bottom", "left bottom", "left", "left top", "center"]).optional(),
-  quality: z36.number().int().min(1).max(100).optional()
+import { z as z37 } from "zod";
+var transformationOptionsSchema = z37.object({
+  width: z37.number().int().positive().optional(),
+  height: z37.number().int().positive().optional(),
+  fit: z37.enum(["cover", "contain", "fill", "inside", "outside"]).optional(),
+  position: z37.enum(["top", "right top", "right", "right bottom", "bottom", "left bottom", "left", "left top", "center"]).optional(),
+  quality: z37.number().int().min(1).max(100).optional()
 });
 var staticOriginSchema2 = LocalDirectorySchema.describe(
   "Specifies the path to a local image directory that will be uploaded in S3."
@@ -1608,38 +1638,38 @@ var staticOriginSchema2 = LocalDirectorySchema.describe(
 var functionOriginSchema2 = FunctionSchema.describe(
   "Specifies the file that will be called when an image isn't found in the (cache) bucket."
 );
-var ImagesSchema = z36.record(
+var ImagesSchema = z37.record(
   ResourceIdSchema,
-  z36.object({
+  z37.object({
     // domain: ResourceIdSchema.describe('The domain id to link your site with.').optional(),
     // subDomain: z.string().optional(),
     router: ResourceIdSchema.describe("The router id to link your image proxy."),
     path: RouteSchema2.describe("The path inside the router to link your image proxy to."),
     log: LogSchema.optional(),
     cacheDuration: DurationSchema.optional().describe("Cache duration of the cached images."),
-    presets: z36.record(z36.string(), transformationOptionsSchema).describe("Named presets for image transformations"),
-    extensions: z36.object({
-      jpg: z36.object({
-        mozjpeg: z36.boolean().optional(),
-        progressive: z36.boolean().optional()
+    presets: z37.record(z37.string(), transformationOptionsSchema).describe("Named presets for image transformations"),
+    extensions: z37.object({
+      jpg: z37.object({
+        mozjpeg: z37.boolean().optional(),
+        progressive: z37.boolean().optional()
       }).optional(),
-      webp: z36.object({
-        effort: z36.number().int().min(1).max(10).default(7).optional(),
-        lossless: z36.boolean().optional(),
-        nearLossless: z36.boolean().optional()
+      webp: z37.object({
+        effort: z37.number().int().min(1).max(10).default(7).optional(),
+        lossless: z37.boolean().optional(),
+        nearLossless: z37.boolean().optional()
       }).optional(),
-      png: z36.object({
-        compressionLevel: z36.number().int().min(0).max(9).default(6).optional()
+      png: z37.object({
+        compressionLevel: z37.number().int().min(0).max(9).default(6).optional()
       }).optional()
     }).refine((data) => {
       return Object.keys(data).length > 0;
     }, "At least one extension must be defined.").describe("Specify the allowed extensions."),
-    origin: z36.union([
-      z36.object({
+    origin: z37.union([
+      z37.object({
         static: staticOriginSchema2,
         function: functionOriginSchema2.optional()
       }),
-      z36.object({
+      z37.object({
         static: staticOriginSchema2.optional(),
         function: functionOriginSchema2
       })
@@ -1654,7 +1684,7 @@ var ImagesSchema = z36.record(
 ).optional().describe("Define an image proxy in your stack. Store, transform, optimize, and deliver images at scale.");
 
 // src/feature/metric/schema.ts
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 var ops = {
   ">": "GreaterThanThreshold",
   ">=": "GreaterThanOrEqualToThreshold",
@@ -1668,15 +1698,15 @@ var stats = {
   min: "Minimum",
   max: "Maximum"
 };
-var WhereSchema = z37.union([
-  z37.string().regex(/(count|avg|sum|min|max) (>|>=|<|<=) (\d)/, "Invalid where query").transform((where) => {
+var WhereSchema = z38.union([
+  z38.string().regex(/(count|avg|sum|min|max) (>|>=|<|<=) (\d)/, "Invalid where query").transform((where) => {
     const [stat4, op, value] = where.split(" ");
     return { stat: stat4, op, value: parseFloat(value) };
   }),
-  z37.object({
-    stat: z37.enum(["count", "avg", "sum", "min", "max"]),
-    op: z37.enum([">", ">=", "<", "<="]),
-    value: z37.number()
+  z38.object({
+    stat: z38.enum(["count", "avg", "sum", "min", "max"]),
+    op: z38.enum([">", ">=", "<", "<="]),
+    value: z38.number()
   })
 ]).transform((where) => {
   return {
@@ -1685,39 +1715,39 @@ var WhereSchema = z37.union([
     value: where.value
   };
 });
-var AlarmSchema = z37.object({
-  description: z37.string().optional(),
+var AlarmSchema = z38.object({
+  description: z38.string().optional(),
   where: WhereSchema,
   period: DurationSchema,
-  minDataPoints: z37.number().int().default(1),
-  trigger: z37.union([EmailSchema.transform((v) => [v]), EmailSchema.array(), FunctionSchema])
+  minDataPoints: z38.number().int().default(1),
+  trigger: z38.union([EmailSchema.transform((v) => [v]), EmailSchema.array(), FunctionSchema])
 });
-var MetricsSchema = z37.record(
+var MetricsSchema = z38.record(
   ResourceIdSchema,
-  z37.object({
-    type: z37.enum(["number", "size", "duration"]),
+  z38.object({
+    type: z38.enum(["number", "size", "duration"]),
     alarms: AlarmSchema.array().optional()
   })
 ).optional().describe("Define the metrics in your stack.");
 
 // src/feature/table/schema.ts
 import { minutes as minutes5, seconds as seconds4 } from "@awsless/duration";
-import { z as z38 } from "zod";
-var KeySchema = z38.string().min(1).max(255);
-var TablesSchema = z38.record(
+import { z as z39 } from "zod";
+var KeySchema = z39.string().min(1).max(255);
+var TablesSchema = z39.record(
   ResourceIdSchema,
-  z38.object({
+  z39.object({
     hash: KeySchema.describe(
       "Specifies the name of the partition / hash key that makes up the primary key for the table."
     ),
     sort: KeySchema.optional().describe(
       "Specifies the name of the range / sort key that makes up the primary key for the table."
     ),
-    fields: z38.record(z38.string(), z38.enum(["string", "number", "binary"])).optional().describe(
+    fields: z39.record(z39.string(), z39.enum(["string", "number", "binary"])).optional().describe(
       'A list of attributes that describe the key schema for the table and indexes. If no attribute field is defined we default to "string".'
     ),
-    class: z38.enum(["standard", "standard-infrequent-access"]).default("standard").describe("The table class of the table."),
-    pointInTimeRecovery: z38.boolean().default(false).describe("Indicates whether point in time recovery is enabled on the table."),
+    class: z39.enum(["standard", "standard-infrequent-access"]).default("standard").describe("The table class of the table."),
+    pointInTimeRecovery: z39.boolean().default(false).describe("Indicates whether point in time recovery is enabled on the table."),
     ttl: KeySchema.optional().describe(
       [
         "The name of the TTL attribute used to store the expiration time for items in the table.",
@@ -1725,8 +1755,8 @@ var TablesSchema = z38.record(
       ].join("\n")
     ),
     // deletionProtection: DeletionProtectionSchema.optional(),
-    stream: z38.object({
-      type: z38.enum(["keys-only", "new-image", "old-image", "new-and-old-images"]).describe(
+    stream: z39.object({
+      type: z39.enum(["keys-only", "new-image", "old-image", "new-and-old-images"]).describe(
         [
           "When an item in the table is modified, you can determines what information is written to the stream for this table.",
           "Valid values are:",
@@ -1736,7 +1766,7 @@ var TablesSchema = z38.record(
           "- new-and-old-images - Both the new and the old item images of the item are written to the stream."
         ].join("\n")
       ),
-      batchSize: z38.number().min(1).max(1e4).default(1).describe(
+      batchSize: z39.number().min(1).max(1e4).default(1).describe(
         [
           "The maximum number of records in each batch that Lambda pulls from your stream and sends to your function.",
           "Lambda passes all of the records in the batch to the function in a single call, up to the payload limit for synchronous invocation (6 MB).",
@@ -1752,17 +1782,20 @@ var TablesSchema = z38.record(
           "You can specify a duration from 1 seconds to 5 minutes."
         ].join("\n")
       ),
-      maxRecordAge: DurationSchema.refine(
-        durationMin(seconds4(1)),
-        "Minimum record age duration is 1 second"
-      ).refine(durationMax(minutes5(1)), "Maximum record age duration is 1 minute").default("60 seconds").describe(
-        [
-          "Discard records older than the specified age.",
-          "The maximum valid value for maximum record age is 60s.",
-          "The default value is 60s"
-        ].join("\n")
-      ),
-      retryAttempts: z38.number().min(-1).max(1e4).default(2).describe(
+      // maxRecordAge: DurationSchema.refine(
+      // 	durationMin(seconds(1)),
+      // 	'Minimum record age duration is 1 second'
+      // )
+      // 	.refine(durationMax(minutes(1)), 'Maximum record age duration is 1 minute')
+      // 	.default('60 seconds')
+      // 	.describe(
+      // 		[
+      // 			'Discard records older than the specified age.',
+      // 			'The maximum valid value for maximum record age is 60s.',
+      // 			'The default value is 60s',
+      // 		].join('\n')
+      // 	),
+      retryAttempts: z39.number().min(-1).max(1e4).default(2).describe(
         [
           "Discard records after the specified number of retries.",
           "-1 will sets the maximum number of retries to infinite.",
@@ -1771,7 +1804,7 @@ var TablesSchema = z38.record(
           "The default value is 2"
         ].join("\n")
       ),
-      concurrencyPerShard: z38.number().min(1).max(10).default(1).describe(
+      concurrencyPerShard: z39.number().min(1).max(10).default(1).describe(
         [
           "The number of batches to process concurrently from each shard.",
           "You can specify a number from 1 to 10."
@@ -1781,16 +1814,16 @@ var TablesSchema = z38.record(
     }).optional().describe(
       "The settings for the DynamoDB table stream, which capture changes to items stored in the table."
     ),
-    indexes: z38.record(
-      z38.string(),
-      z38.object({
-        hash: z38.union([KeySchema.transform((v) => [v]), KeySchema.array()]).describe(
+    indexes: z39.record(
+      z39.string(),
+      z39.object({
+        hash: z39.union([KeySchema.transform((v) => [v]), KeySchema.array()]).describe(
           "Specifies the name of the partition / hash key that makes up the primary key for the global secondary index."
         ),
-        sort: z38.union([KeySchema.transform((v) => [v]), KeySchema.array()]).optional().describe(
+        sort: z39.union([KeySchema.transform((v) => [v]), KeySchema.array()]).optional().describe(
           "Specifies the name of the range / sort key that makes up the primary key for the global secondary index."
         ),
-        projection: z38.enum(["all", "keys-only"]).default("all").describe(
+        projection: z39.enum(["all", "keys-only"]).default("all").describe(
           [
             "The set of attributes that are projected into the index:",
             "- all - All of the table attributes are projected into the index.",
@@ -1803,29 +1836,6 @@ var TablesSchema = z38.record(
   })
 ).optional().describe("Define the tables in your stack.");
 
-// src/feature/task/schema.ts
-import { z as z39 } from "zod";
-var RetryAttemptsSchema3 = z39.number().int().min(0).max(2).describe(
-  "The maximum number of times to retry when the function returns an error. You can specify a number from 0 to 2."
-);
-var TaskSchema = z39.union([
-  LocalFileSchema.transform((file) => ({
-    consumer: {
-      code: {
-        file,
-        minify: true,
-        external: []
-      }
-    },
-    retryAttempts: void 0
-  })),
-  z39.object({
-    consumer: FunctionSchema,
-    retryAttempts: RetryAttemptsSchema3.optional()
-  })
-]);
-var TasksSchema = z39.record(ResourceIdSchema, TaskSchema).optional().describe("Define the tasks in your stack.");
-
 // src/feature/test/schema.ts
 import { z as z40 } from "zod";
 var TestsSchema = z40.union([