@awsless/awsless 0.0.208 → 0.0.209

package/dist/build-json-schema.js

@@ -2,7 +2,7 @@
 import { zodToJsonSchema } from "zod-to-json-schema";
 
 // src/config/stack.ts
-import { z as z23 } from "zod";
+import { z as z25 } from "zod";
 
 // src/config/schema/resource-id.ts
 import { paramCase } from "change-case";
@@ -397,13 +397,33 @@ var PubSubSchema = z11.record(
   })
 ).optional().describe("Define the pubsub subscriber in your stack.");
 
-// src/feature/test/schema.ts
+// src/feature/rest/schema.ts
 import { z as z13 } from "zod";
 
+// src/config/schema/route.ts
+import { z as z12 } from "zod";
+var RouteSchema = z12.union([
+  z12.string().regex(/^(POST|GET|PUT|DELETE|HEAD|OPTIONS)(\s\/[a-z0-9\+\_\-\/\{\}]*)$/gi, "Invalid route"),
+  z12.literal("$default")
+]);
+
+// src/feature/rest/schema.ts
+var RestDefaultSchema = z13.record(
+  ResourceIdSchema,
+  z13.object({
+    domain: ResourceIdSchema.describe("The domain id to link your API with.").optional(),
+    subDomain: z13.string().optional()
+  })
+).optional().describe("Define your global REST API's.");
+var RestSchema = z13.record(ResourceIdSchema, z13.record(RouteSchema, FunctionSchema)).optional().describe("Define routes in your stack for your global REST API.");
+
+// src/feature/test/schema.ts
+import { z as z15 } from "zod";
+
 // src/config/schema/local-directory.ts
 import { stat as stat2 } from "fs/promises";
-import { z as z12 } from "zod";
-var LocalDirectorySchema = z12.string().transform((path) => resolvePath(path)).refine(async (path) => {
+import { z as z14 } from "zod";
+var LocalDirectorySchema = z14.string().transform((path) => resolvePath(path)).refine(async (path) => {
   try {
     const s = await stat2(path);
     return s.isDirectory();
@@ -413,32 +433,32 @@ var LocalDirectorySchema = z12.string().transform((path) => resolvePath(path)).r
 }, `Directory doesn't exist`);
 
 // src/feature/test/schema.ts
-var TestsSchema = z13.union([LocalDirectorySchema.transform((v) => [v]), LocalDirectorySchema.array()]).describe("Define the location of your tests for your stack.").optional();
+var TestsSchema = z15.union([LocalDirectorySchema.transform((v) => [v]), LocalDirectorySchema.array()]).describe("Define the location of your tests for your stack.").optional();
 
 // src/feature/topic/schema.ts
 import { paramCase as paramCase2 } from "change-case";
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 
 // src/config/schema/email.ts
-import { z as z14 } from "zod";
-var EmailSchema = z14.string().email();
+import { z as z16 } from "zod";
+var EmailSchema = z16.string().email();
 
 // src/feature/topic/schema.ts
-var TopicNameSchema = z15.string().min(3).max(256).regex(/^[a-z0-9\-]+$/i, "Invalid topic name").transform((value) => paramCase2(value)).describe("Define event topic name.");
-var TopicsSchema = z15.array(TopicNameSchema).refine((topics) => {
+var TopicNameSchema = z17.string().min(3).max(256).regex(/^[a-z0-9\-]+$/i, "Invalid topic name").transform((value) => paramCase2(value)).describe("Define event topic name.");
+var TopicsSchema = z17.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 to publish too in your stack.");
-var SubscribersSchema = z15.record(TopicNameSchema, z15.union([EmailSchema, FunctionSchema])).optional().describe("Define the events to subscribe too in your stack.");
+var SubscribersSchema = z17.record(TopicNameSchema, z17.union([EmailSchema, FunctionSchema])).optional().describe("Define the events to subscribe too in your stack.");
 
 // src/feature/cron/schema/index.ts
-import { z as z17 } from "zod";
+import { z as z19 } from "zod";
 
 // src/feature/cron/schema/schedule.ts
-import { z as z16 } from "zod";
+import { z as z18 } from "zod";
 import { awsCronExpressionValidator } from "aws-cron-expression-validator";
-var RateExpressionSchema = z16.custom(
+var RateExpressionSchema = z18.custom(
   (value) => {
-    return z16.string().regex(/^[0-9]+ (seconds?|minutes?|hours?|days?)$/).refine((rate) => {
+    return z18.string().regex(/^[0-9]+ (seconds?|minutes?|hours?|days?)$/).refine((rate) => {
       const [str] = rate.split(" ");
       const number = parseInt(str);
       return number > 0;
@@ -454,9 +474,9 @@ var RateExpressionSchema = z16.custom(
   }
   return `rate(${rate})`;
 });
-var CronExpressionSchema = z16.custom(
+var CronExpressionSchema = z18.custom(
   (value) => {
-    return z16.string().safeParse(value).success;
+    return z18.string().safeParse(value).success;
   },
   { message: "Invalid cron expression" }
 ).superRefine((value, ctx) => {
@@ -465,12 +485,12 @@ var CronExpressionSchema = z16.custom(
   } catch (error) {
     if (error instanceof Error) {
       ctx.addIssue({
-        code: z16.ZodIssueCode.custom,
+        code: z18.ZodIssueCode.custom,
         message: `Invalid cron expression: ${error.message}`
       });
     } else {
       ctx.addIssue({
-        code: z16.ZodIssueCode.custom,
+        code: z18.ZodIssueCode.custom,
         message: "Invalid cron expression"
       });
     }
@@ -481,21 +501,21 @@ var CronExpressionSchema = z16.custom(
 var ScheduleExpressionSchema = RateExpressionSchema.or(CronExpressionSchema);
 
 // src/feature/cron/schema/index.ts
-var CronsSchema = z17.record(
+var CronsSchema = z19.record(
   ResourceIdSchema,
-  z17.object({
-    enabled: z17.boolean().default(true).describe("If the cron is enabled."),
+  z19.object({
+    enabled: z19.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: z17.unknown().optional().describe("The JSON payload that will be passed to the consumer.")
+    payload: z19.unknown().optional().describe("The JSON payload that will be passed to the consumer.")
   })
 ).optional();
 
 // src/feature/cache/schema.ts
-import { z as z18 } from "zod";
-var TypeSchema = z18.enum([
+import { z as z20 } from "zod";
+var TypeSchema = z20.enum([
   "t4g.small",
   "t4g.medium",
   "r6g.large",
@@ -510,25 +530,25 @@ var TypeSchema = z18.enum([
   "r6gd.4xlarge",
   "r6gd.8xlarge"
 ]);
-var PortSchema = z18.number().int().min(1).max(5e4);
-var ShardsSchema = z18.number().int().min(0).max(100);
-var ReplicasPerShardSchema = z18.number().int().min(0).max(5);
-var EngineSchema = z18.enum(["7.0", "6.2"]);
-var CachesSchema = z18.record(
+var PortSchema = z20.number().int().min(1).max(5e4);
+var ShardsSchema = z20.number().int().min(0).max(100);
+var ReplicasPerShardSchema = z20.number().int().min(0).max(5);
+var EngineSchema = z20.enum(["7.0", "6.2"]);
+var CachesSchema = z20.record(
   ResourceIdSchema,
-  z18.object({
+  z20.object({
     type: TypeSchema.default("t4g.small"),
     port: PortSchema.default(6379),
     shards: ShardsSchema.default(1),
     replicasPerShard: ReplicasPerShardSchema.default(1),
     engine: EngineSchema.default("7.0"),
-    dataTiering: z18.boolean().default(false)
+    dataTiering: z20.boolean().default(false)
   })
 ).optional().describe("Define the caches in your stack. For access to the cache put your functions inside the global VPC.");
 
 // src/feature/auth/schema.ts
-import { z as z19 } from "zod";
-var TriggersSchema = z19.object({
+import { z as z21 } from "zod";
+var TriggersSchema = z21.object({
   beforeToken: FunctionSchema.optional().describe("A pre jwt token generation AWS Lambda trigger."),
   beforeLogin: FunctionSchema.optional().describe("A pre user login AWS Lambda trigger."),
   afterLogin: FunctionSchema.optional().describe("A post user login AWS Lambda trigger."),
@@ -541,42 +561,42 @@ var TriggersSchema = z19.object({
   createChallenge: FunctionSchema.optional().describe("Creates an authentication challenge."),
   verifyChallenge: FunctionSchema.optional().describe("Verifies the authentication challenge response.")
 }).describe("Specifies the configuration for AWS Lambda triggers.");
-var AuthSchema = z19.record(
+var AuthSchema = z21.record(
   ResourceIdSchema,
-  z19.object({
-    access: z19.boolean().default(false).describe("Give access to every function in this stack to your cognito instance."),
+  z21.object({
+    access: z21.boolean().default(false).describe("Give access to every function in this stack to your cognito instance."),
     triggers: TriggersSchema.optional()
   })
 ).optional().describe("Define the auth triggers in your stack.");
-var AuthDefaultSchema = z19.record(
+var AuthDefaultSchema = z21.record(
   ResourceIdSchema,
-  z19.object({
-    allowUserRegistration: z19.boolean().default(true).describe("Specifies whether users can create an user account or if only the administrator can."),
-    messaging: z19.object({
+  z21.object({
+    allowUserRegistration: z21.boolean().default(true).describe("Specifies whether users can create an user account or if only the administrator can."),
+    messaging: z21.object({
       fromEmail: EmailSchema.describe("Specifies the sender's email address."),
-      fromName: z19.string().optional().describe("Specifies the sender's name."),
+      fromName: z21.string().optional().describe("Specifies the sender's name."),
       replyTo: EmailSchema.optional().describe(
         "The destination to which the receiver of the email should reply."
       )
     }).optional().describe("The email configuration for sending messages."),
     // secret: z.boolean().default(false).describe('Specifies whether you want to generate a client secret.'),
-    username: z19.object({
-      emailAlias: z19.boolean().default(true).describe("Allow the user email to be used as username."),
-      caseSensitive: z19.boolean().default(false).describe(
+    username: z21.object({
+      emailAlias: z21.boolean().default(true).describe("Allow the user email to be used as username."),
+      caseSensitive: z21.boolean().default(false).describe(
         "Specifies whether username case sensitivity will be enabled. When usernames and email addresses are case insensitive, users can sign in as the same user when they enter a different capitalization of their user name."
       )
     }).default({}).describe("The username policy."),
-    password: z19.object({
-      minLength: z19.number().int().min(6).max(99).default(12).describe("Required users to have at least the minimum password length."),
-      uppercase: z19.boolean().default(true).describe("Required users to use at least one uppercase letter in their password."),
-      lowercase: z19.boolean().default(true).describe("Required users to use at least one lowercase letter in their password."),
-      numbers: z19.boolean().default(true).describe("Required users to use at least one number in their password."),
-      symbols: z19.boolean().default(true).describe("Required users to use at least one symbol in their password."),
+    password: z21.object({
+      minLength: z21.number().int().min(6).max(99).default(12).describe("Required users to have at least the minimum password length."),
+      uppercase: z21.boolean().default(true).describe("Required users to use at least one uppercase letter in their password."),
+      lowercase: z21.boolean().default(true).describe("Required users to use at least one lowercase letter in their password."),
+      numbers: z21.boolean().default(true).describe("Required users to use at least one number in their password."),
+      symbols: z21.boolean().default(true).describe("Required users to use at least one symbol in their password."),
       temporaryPasswordValidity: DurationSchema.default("7 days").describe(
         "The duration a temporary password is valid. If the user doesn't sign in during this time, an administrator must reset their password."
       )
     }).default({}).describe("The password policy."),
-    validity: z19.object({
+    validity: z21.object({
       idToken: DurationSchema.default("1 hour").describe(
         "The ID token time limit. After this limit expires, your user can't use their ID token."
       ),
@@ -592,23 +612,23 @@ var AuthDefaultSchema = z19.record(
 ).default({}).describe("Define the authenticatable users in your app.");
 
 // src/feature/http/schema.ts
-import { z as z20 } from "zod";
-var RouteSchema = z20.string().regex(/^(POST|GET|PUT|DELETE|HEAD|OPTIONS)(\s\/[a-z0-9\+\_\-\/\{\}]*)$/gi, "Invalid route").transform((v) => v);
-var HttpDefaultSchema = z20.record(
+import { z as z22 } from "zod";
+var RouteSchema2 = z22.string().regex(/^(POST|GET|PUT|DELETE|HEAD|OPTIONS)(\s\/[a-z0-9\+\_\-\/\{\}]*)$/gi, "Invalid route").transform((v) => v);
+var HttpDefaultSchema = z22.record(
   ResourceIdSchema,
-  z20.object({
+  z22.object({
     domain: ResourceIdSchema.describe("The domain id to link your API with."),
-    subDomain: z20.string().optional()
+    subDomain: z22.string().optional()
     // auth: ResourceIdSchema.optional(),
   })
 ).optional().describe("Define your global HTTP API's.");
-var HttpSchema = z20.record(ResourceIdSchema, z20.record(RouteSchema, FunctionSchema)).optional().describe("Define routes in your stack for your global HTTP API.");
+var HttpSchema = z22.record(ResourceIdSchema, z22.record(RouteSchema2, FunctionSchema)).optional().describe("Define routes in your stack for your global HTTP API.");
 
 // src/feature/search/schema.ts
-import { z as z21 } from "zod";
+import { z as z23 } from "zod";
 import { gibibytes as gibibytes2 } from "@awsless/size";
-var VersionSchema = z21.enum(["2.11", "2.9", "2.7", "2.5", "2.3", "1.3"]);
-var TypeSchema2 = z21.enum([
+var VersionSchema = z23.enum(["2.11", "2.9", "2.7", "2.5", "2.3", "1.3"]);
+var TypeSchema2 = z23.enum([
   "t3.small",
   "t3.medium",
   "t3.large",
@@ -709,41 +729,41 @@ var TypeSchema2 = z21.enum([
   "r6gd.16xlarge"
 ]);
 var StorageSizeSchema = SizeSchema.refine(sizeMin(gibibytes2(10)), "Minimum storage size is 10 GB").refine(sizeMax(gibibytes2(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 = z21.record(
+var SearchsSchema = z23.record(
   ResourceIdSchema,
-  z21.object({
+  z23.object({
     type: TypeSchema2.default("t3.small"),
-    count: z21.number().int().min(1).default(1),
+    count: z23.number().int().min(1).default(1),
     version: VersionSchema.default("2.11"),
     storage: StorageSizeSchema.default("10 GB"),
-    vpc: z21.boolean().default(false)
+    vpc: z23.boolean().default(false)
   })
 ).optional().describe("Define the search instances in your stack. Backed by OpenSearch.");
 
 // src/feature/site/schema.ts
-import { z as z22 } from "zod";
-var ErrorResponsePathSchema = z22.string().describe(
+import { z as z24 } from "zod";
+var ErrorResponsePathSchema = z24.string().describe(
   "The path to the custom error page that you want to return to the viewer when your origin returns the HTTP status code specified.\n - We recommend that you store custom error pages in an Amazon S3 bucket. If you store custom error pages on an HTTP server and the server starts to return 5xx errors, CloudFront can't get the files that you want to return to viewers because the origin server is unavailable."
 );
-var StatusCodeSchema = z22.number().int().positive().optional().describe(
+var StatusCodeSchema = z24.number().int().positive().optional().describe(
   "The HTTP status code that you want CloudFront to return to the viewer along with the custom error page. There are a variety of reasons that you might want CloudFront to return a status code different from the status code that your origin returned to CloudFront, for example:\n- Some Internet devices (some firewalls and corporate proxies, for example) intercept HTTP 4xx and 5xx and prevent the response from being returned to the viewer. If you substitute 200, the response typically won't be intercepted.\n- If you don't care about distinguishing among different client errors or server errors, you can specify 400 or 500 as the ResponseCode for all 4xx or 5xx errors.\n- You might want to return a 200 status code (OK) and static website so your customers don't know that your website is down."
 );
 var MinTTLSchema = DurationSchema.describe(
   "The minimum amount of time, that you want to cache the error response. When this time period has elapsed, CloudFront queries your origin to see whether the problem that caused the error has been resolved and the requested object is now available."
 );
-var ErrorResponseSchema = z22.union([
+var ErrorResponseSchema = z24.union([
   ErrorResponsePathSchema,
-  z22.object({
+  z24.object({
     path: ErrorResponsePathSchema,
     statusCode: StatusCodeSchema.optional(),
     minTTL: MinTTLSchema.optional()
   })
 ]).optional();
-var SitesSchema = z22.record(
+var SitesSchema = z24.record(
   ResourceIdSchema,
-  z22.object({
+  z24.object({
     domain: ResourceIdSchema.describe("The domain id to link your site with."),
-    subDomain: z22.string().optional(),
+    subDomain: z24.string().optional(),
     static: LocalDirectorySchema.optional().describe("Specifies the path to the static files directory."),
     ssr: FunctionSchema.optional().describe("Specifies the ssr file."),
     // bind: z.object({
@@ -758,7 +778,7 @@ var SitesSchema = z22.record(
     // 		build: z.string().optional(),
     // 	}),
     // ]),
-    errors: z22.object({
+    errors: z24.object({
       400: ErrorResponseSchema.describe("Customize a `400 Bad Request` response."),
       403: ErrorResponseSchema.describe("Customize a `403 Forbidden` response."),
       404: ErrorResponseSchema.describe("Customize a `404 Not Found` response."),
@@ -771,16 +791,16 @@ var SitesSchema = z22.record(
       503: ErrorResponseSchema.describe("Customize a `503 Service Unavailable` response."),
       504: ErrorResponseSchema.describe("Customize a `504 Gateway Timeout` response.")
     }).optional().describe("Customize the error responses for specific HTTP status codes."),
-    cors: z22.object({
-      override: z22.boolean().default(false),
+    cors: z24.object({
+      override: z24.boolean().default(false),
       maxAge: DurationSchema.default("365 days"),
-      exposeHeaders: z22.string().array().optional(),
-      credentials: z22.boolean().default(false),
-      headers: z22.string().array().default(["*"]),
-      origins: z22.string().array().default(["*"]),
-      methods: z22.enum(["GET", "DELETE", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "ALL"]).array().default(["ALL"])
+      exposeHeaders: z24.string().array().optional(),
+      credentials: z24.boolean().default(false),
+      headers: z24.string().array().default(["*"]),
+      origins: z24.string().array().default(["*"]),
+      methods: z24.enum(["GET", "DELETE", "HEAD", "OPTIONS", "PATCH", "POST", "PUT", "ALL"]).array().default(["ALL"])
     }).optional().describe("Define the cors headers."),
-    security: z22.object({
+    security: z24.object({
       // contentSecurityPolicy: z.object({
       // 	override: z.boolean().default(false),
       // 	policy: z.string(),
@@ -822,10 +842,10 @@ var SitesSchema = z22.record(
       // 	reportUri?: string
       // }
     }).optional().describe("Define the security policy."),
-    cache: z22.object({
-      cookies: z22.string().array().optional().describe("Specifies the cookies that CloudFront includes in the cache key."),
-      headers: z22.string().array().optional().describe("Specifies the headers that CloudFront includes in the cache key."),
-      queries: z22.string().array().optional().describe("Specifies the query values that CloudFront includes in the cache key.")
+    cache: z24.object({
+      cookies: z24.string().array().optional().describe("Specifies the cookies that CloudFront includes in the cache key."),
+      headers: z24.string().array().optional().describe("Specifies the headers that CloudFront includes in the cache key."),
+      queries: z24.string().array().optional().describe("Specifies the query values that CloudFront includes in the cache key.")
     }).optional().describe(
       "Specifies the cookies, headers, and query values that CloudFront includes in the cache key."
     )
@@ -837,15 +857,15 @@ var DependsSchema = ResourceIdSchema.array().optional().describe("Define the sta
 var NameSchema = ResourceIdSchema.refine((name) => !["base"].includes(name), {
   message: `Stack name can't be a reserved name.`
 }).describe("Stack name.");
-var StackSchema = z23.object({
-  $schema: z23.string().optional(),
+var StackSchema = z25.object({
+  $schema: z25.string().optional(),
   name: NameSchema,
   depends: DependsSchema,
   onFailure: OnFailureSchema,
   auth: AuthSchema,
   graphql: GraphQLSchema,
   http: HttpSchema,
-  // rest: RestSchema,
+  rest: RestSchema,
   configs: ConfigsSchema,
   crons: CronsSchema,
   caches: CachesSchema,
@@ -862,10 +882,10 @@ var StackSchema = z23.object({
 });
 
 // src/config/app.ts
-import { z as z26 } from "zod";
+import { z as z28 } from "zod";
 
 // src/config/schema/region.ts
-import { z as z24 } from "zod";
+import { z as z26 } from "zod";
 var US = ["us-east-2", "us-east-1", "us-west-1", "us-west-2"];
 var AF = ["af-south-1"];
 var AP = [
@@ -894,21 +914,21 @@ 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 = z26.enum(regions);
 
 // src/feature/domain/schema.ts
-import { z as z25 } from "zod";
-var DomainNameSchema = z25.string().regex(/[a-z\-\_\.]/g, "Invalid domain name").describe(
+import { z as z27 } from "zod";
+var DomainNameSchema = z27.string().regex(/[a-z\-\_\.]/g, "Invalid domain name").describe(
   "Enter a fully qualified domain name, for example, www.example.com. You can optionally include a trailing dot. If you omit the trailing dot, Amazon Route 53 assumes that the domain name that you specify is fully qualified. This means that Route 53 treats www.example.com (without a trailing dot) and www.example.com. (with a trailing dot) as identical."
 );
-var DNSTypeSchema = z25.enum(["A", "AAAA", "CAA", "CNAME", "DS", "MX", "NAPTR", "NS", "PTR", "SOA", "SPF", "SRV", "TXT"]).describe("The DNS record type.");
+var DNSTypeSchema = z27.enum(["A", "AAAA", "CAA", "CNAME", "DS", "MX", "NAPTR", "NS", "PTR", "SOA", "SPF", "SRV", "TXT"]).describe("The DNS record type.");
 var TTLSchema = DurationSchema.describe("The resource record cache time to live (TTL).");
-var RecordsSchema = z25.string().array().describe("One or more values that correspond with the value that you specified for the Type property.");
-var DomainsDefaultSchema = z25.record(
+var RecordsSchema = z27.string().array().describe("One or more values that correspond with the value that you specified for the Type property.");
+var DomainsDefaultSchema = z27.record(
   ResourceIdSchema,
-  z25.object({
+  z27.object({
     domain: DomainNameSchema.describe("Define the domain name"),
-    dns: z25.object({
+    dns: z27.object({
       name: DomainNameSchema.optional(),
       type: DNSTypeSchema,
       ttl: TTLSchema,
@@ -918,24 +938,24 @@ var DomainsDefaultSchema = z25.record(
 ).optional().describe("Define the domains for your application.");
 
 // src/config/app.ts
-var AppSchema = z26.object({
-  $schema: z26.string().optional(),
+var AppSchema = z28.object({
+  $schema: z28.string().optional(),
   name: ResourceIdSchema.describe("App name."),
   region: RegionSchema.describe("The AWS region to deploy to."),
-  profile: z26.string().describe("The AWS profile to deploy to."),
+  profile: z28.string().describe("The AWS profile to deploy to."),
   // stage: z
   // 	.string()
   // 	.regex(/^[a-z]+$/)
   // 	.default('prod')
   // 	.describe('The deployment stage.'),
-  defaults: z26.object({
+  defaults: z28.object({
     auth: AuthDefaultSchema,
     domains: DomainsDefaultSchema,
     function: FunctionDefaultSchema,
     queue: QueueDefaultSchema,
     graphql: GraphQLDefaultSchema,
-    http: HttpDefaultSchema
-    // rest: RestDefaultSchema,
+    http: HttpDefaultSchema,
+    rest: RestDefaultSchema
   }).default({}).describe("Default properties")
 });