@awsless/awsless 0.0.298 → 0.0.300

package/dist/bin.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin.js

@@ -372,7 +372,7 @@ var debug = (...parts) => {
 };
 
 // src/config/app.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 
 // src/feature/auth/schema.ts
 import { z as z7 } from "zod";
@@ -770,8 +770,35 @@ var InstancesSchema = z12.record(
   })
 ).optional().describe("Define the instances in your stack.");
 
-// src/feature/queue/schema.ts
+// src/feature/pubsub/schema.ts
 import { z as z13 } from "zod";
+var RealTimeDefaultSchema = z13.record(
+  ResourceIdSchema,
+  z13.object({
+    auth: z13.union([
+      ResourceIdSchema,
+      z13.object({
+        authorizer: FunctionSchema
+        // ttl: AuthorizerTtl.default('1 hour'),
+      })
+    ]),
+    policy: z13.object({
+      publish: z13.array(z13.string()).optional(),
+      subscribe: z13.array(z13.string()).optional()
+    })
+  })
+).optional().describe("Define the pubsub subscriber in your stack.");
+var PubSubSchema = z13.record(
+  ResourceIdSchema,
+  z13.object({
+    sql: z13.string().describe("The SQL statement used to query the IOT topic."),
+    sqlVersion: z13.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.")
+  })
+).optional().describe("Define the pubsub subscriber in your stack.");
+
+// src/feature/queue/schema.ts
+import { z as z14 } from "zod";
 import { days as days2, hours, minutes as minutes3, seconds as seconds2 } from "@awsless/duration";
 import { kibibytes } from "@awsless/size";
 var RetentionPeriodSchema = DurationSchema.refine(
@@ -801,10 +828,10 @@ var ReceiveMessageWaitTimeSchema = DurationSchema.refine(
 var MaxMessageSizeSchema = SizeSchema.refine(sizeMin(kibibytes(1)), "Minimum max message size is 1 KB").refine(sizeMax(kibibytes(256)), "Maximum max message size is 256 KB").describe(
   "The limit of how many bytes that a message can contain before Amazon SQS rejects it. You can specify an size from 1 KB to 256 KB."
 );
-var BatchSizeSchema = z13.number().int().min(1, "Minimum batch size is 1").max(1e4, "Maximum batch size is 10000").describe(
+var BatchSizeSchema = z14.number().int().min(1, "Minimum batch size is 1").max(1e4, "Maximum batch size is 10000").describe(
   "The maximum number of records in each batch that Lambda pulls from your queue 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). You can specify an integer from 1 to 10000."
 );
-var MaxConcurrencySchema = z13.number().int().min(2, "Minimum max concurrency is 2").max(1e3, "Maximum max concurrency is 1000").describe(
+var MaxConcurrencySchema = z14.number().int().min(2, "Minimum max concurrency is 2").max(1e3, "Maximum max concurrency is 1000").describe(
   "Limits the number of concurrent instances that the queue worker can invoke. You can specify an integer from 2 to 1000."
 );
 var MaxBatchingWindow = DurationSchema.refine(
@@ -813,7 +840,7 @@ var MaxBatchingWindow = DurationSchema.refine(
 ).describe(
   "The maximum amount of time, that Lambda spends gathering records before invoking the function. You can specify an duration from 0 seconds to 5 minutes."
 );
-var QueueDefaultSchema = z13.object({
+var QueueDefaultSchema = z14.object({
   retentionPeriod: RetentionPeriodSchema.default("7 days"),
   visibilityTimeout: VisibilityTimeoutSchema.default("30 seconds"),
   deliveryDelay: DeliveryDelaySchema.default("0 seconds"),
@@ -823,15 +850,15 @@ var QueueDefaultSchema = z13.object({
   maxConcurrency: MaxConcurrencySchema.optional(),
   maxBatchingWindow: MaxBatchingWindow.optional()
 }).default({});
-var QueuesSchema = z13.record(
+var QueuesSchema = z14.record(
   ResourceIdSchema,
-  z13.union([
+  z14.union([
     LocalFileSchema.transform((file) => ({
       consumer: {
         file
       }
     })),
-    z13.object({
+    z14.object({
       consumer: FunctionSchema.describe("he consuming lambda function properties."),
       retentionPeriod: RetentionPeriodSchema.optional(),
       visibilityTimeout: VisibilityTimeoutSchema.optional(),
@@ -846,27 +873,27 @@ var QueuesSchema = z13.record(
 ).optional().describe("Define the queues in your stack.");
 
 // src/feature/rest/schema.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/config/schema/route.ts
-import { z as z14 } from "zod";
-var RouteSchema2 = z14.union([
-  z14.string().regex(/^(POST|GET|PUT|DELETE|HEAD|OPTIONS)(\s\/[a-z0-9\+\_\-\/\{\}]*)$/gi, "Invalid route"),
-  z14.literal("$default")
+import { z as z15 } from "zod";
+var RouteSchema2 = z15.union([
+  z15.string().regex(/^(POST|GET|PUT|DELETE|HEAD|OPTIONS)(\s\/[a-z0-9\+\_\-\/\{\}]*)$/gi, "Invalid route"),
+  z15.literal("$default")
 ]);
 
 // src/feature/rest/schema.ts
-var RestDefaultSchema = z15.record(
+var RestDefaultSchema = z16.record(
   ResourceIdSchema,
-  z15.object({
+  z16.object({
     domain: ResourceIdSchema.describe("The domain id to link your API with.").optional(),
-    subDomain: z15.string().optional()
+    subDomain: z16.string().optional()
   })
 ).optional().describe("Define your global REST API's.");
-var RestSchema = z15.record(ResourceIdSchema, z15.record(RouteSchema2, FunctionSchema)).optional().describe("Define routes in your stack for your global REST API.");
+var RestSchema = z16.record(ResourceIdSchema, z16.record(RouteSchema2, FunctionSchema)).optional().describe("Define routes in your stack for your global REST API.");
 
 // src/config/schema/region.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var US = ["us-east-2", "us-east-1", "us-west-1", "us-west-2"];
 var AF = ["af-south-1"];
 var AP = [
@@ -895,20 +922,20 @@ 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 = z16.enum(regions);
+var RegionSchema = z17.enum(regions);
 
 // src/config/app.ts
-var AppSchema = z17.object({
-  $schema: z17.string().optional(),
+var AppSchema = z18.object({
+  $schema: z18.string().optional(),
   name: ResourceIdSchema.describe("App name."),
   region: RegionSchema.describe("The AWS region to deploy to."),
-  profile: z17.string().describe("The AWS profile to deploy to."),
+  profile: z18.string().describe("The AWS profile to deploy to."),
   // stage: z
   // 	.string()
   // 	.regex(/^[a-z]+$/)
   // 	.default('prod')
   // 	.describe('The deployment stage.'),
-  defaults: z17.object({
+  defaults: z18.object({
     auth: AuthDefaultSchema,
     domains: DomainsDefaultSchema,
     function: FunctionDefaultSchema,
@@ -916,7 +943,8 @@ var AppSchema = z17.object({
     queue: QueueDefaultSchema,
     graphql: GraphQLDefaultSchema,
     http: HttpDefaultSchema,
-    rest: RestDefaultSchema
+    rest: RestDefaultSchema,
+    realtime: RealTimeDefaultSchema
   }).default({}).describe("Default properties")
 });
 
@@ -927,8 +955,8 @@ import { glob } from "glob";
 import { z as z32 } from "zod";
 
 // src/feature/cache/schema.ts
-import { z as z18 } from "zod";
-var TypeSchema2 = z18.enum([
+import { z as z19 } from "zod";
+var TypeSchema2 = z19.enum([
   "t4g.small",
   "t4g.medium",
   "r6g.large",
@@ -943,54 +971,54 @@ var TypeSchema2 = 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 = z19.number().int().min(1).max(5e4);
+var ShardsSchema = z19.number().int().min(0).max(100);
+var ReplicasPerShardSchema = z19.number().int().min(0).max(5);
+var EngineSchema = z19.enum(["7.0", "6.2"]);
+var CachesSchema = z19.record(
   ResourceIdSchema,
-  z18.object({
+  z19.object({
     type: TypeSchema2.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: z19.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/command/schema.ts
-import { z as z19 } from "zod";
-var CommandSchema2 = z19.union([
-  z19.object({
+import { z as z20 } from "zod";
+var CommandSchema2 = z20.union([
+  z20.object({
     file: LocalFileSchema,
-    handler: z19.string().default("default").describe("The name of the handler that needs to run"),
-    description: z19.string().optional().describe("A description of the command")
+    handler: z20.string().default("default").describe("The name of the handler that needs to run"),
+    description: z20.string().optional().describe("A description of the command")
     // options: z.record(ResourceIdSchema, OptionSchema).optional(),
     // arguments: z.record(ResourceIdSchema, ArgumentSchema).optional(),
   }),
-  z19.string().transform((file) => ({
+  z20.string().transform((file) => ({
     file,
     handler: "default",
     description: void 0
   }))
 ]);
-var CommandsSchema = z19.record(ResourceIdSchema, CommandSchema2).optional().describe("Define the custom commands for your stack.");
+var CommandsSchema = z20.record(ResourceIdSchema, CommandSchema2).optional().describe("Define the custom commands for your stack.");
 
 // src/feature/config/schema.ts
-import { z as z20 } from "zod";
-var ConfigNameSchema = z20.string().regex(/[a-z0-9\-]/g, "Invalid config name");
-var ConfigsSchema = z20.array(ConfigNameSchema).optional().describe("Define the config values for your stack.");
+import { z as z21 } from "zod";
+var ConfigNameSchema = z21.string().regex(/[a-z0-9\-]/g, "Invalid config name");
+var ConfigsSchema = z21.array(ConfigNameSchema).optional().describe("Define the config values for your stack.");
 
 // src/feature/cron/schema/index.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 
 // src/feature/cron/schema/schedule.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 import { awsCronExpressionValidator } from "aws-cron-expression-validator";
-var RateExpressionSchema = z21.custom(
+var RateExpressionSchema = z22.custom(
   (value) => {
-    return z21.string().regex(/^[0-9]+ (seconds?|minutes?|hours?|days?)$/).refine((rate) => {
+    return z22.string().regex(/^[0-9]+ (seconds?|minutes?|hours?|days?)$/).refine((rate) => {
       const [str] = rate.split(" ");
       const number = parseInt(str);
       return number > 0;
@@ -1006,9 +1034,9 @@ var RateExpressionSchema = z21.custom(
   }
   return `rate(${rate})`;
 });
-var CronExpressionSchema = z21.custom(
+var CronExpressionSchema = z22.custom(
   (value) => {
-    return z21.string().safeParse(value).success;
+    return z22.string().safeParse(value).success;
   },
   { message: "Invalid cron expression" }
 ).superRefine((value, ctx) => {
@@ -1017,12 +1045,12 @@ var CronExpressionSchema = z21.custom(
   } catch (error) {
     if (error instanceof Error) {
       ctx.addIssue({
-        code: z21.ZodIssueCode.custom,
+        code: z22.ZodIssueCode.custom,
         message: `Invalid cron expression: ${error.message}`
       });
     } else {
       ctx.addIssue({
-        code: z21.ZodIssueCode.custom,
+        code: z22.ZodIssueCode.custom,
         message: "Invalid cron expression"
       });
     }
@@ -1033,15 +1061,15 @@ var CronExpressionSchema = z21.custom(
 var ScheduleExpressionSchema = RateExpressionSchema.or(CronExpressionSchema);
 
 // src/feature/cron/schema/index.ts
-var CronsSchema = z22.record(
+var CronsSchema = z23.record(
   ResourceIdSchema,
-  z22.object({
-    enabled: z22.boolean().default(true).describe("If the cron is enabled."),
+  z23.object({
+    enabled: z23.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: z22.unknown().optional().describe("The JSON payload that will be passed to the consumer.")
+    payload: z23.unknown().optional().describe("The JSON payload that will be passed to the consumer.")
   })
 ).optional();
 
@@ -1050,17 +1078,6 @@ var OnFailureSchema = FunctionSchema.optional().describe(
   "Defining a onFailure handler will add a global onFailure handler for the following resources:\n- Async lambda functions\n- SQS queues\n- DynamoDB streams"
 );
 
-// src/feature/pubsub/schema.ts
-import { z as z23 } from "zod";
-var PubSubSchema = z23.record(
-  ResourceIdSchema,
-  z23.object({
-    sql: z23.string().describe("The SQL statement used to query the IOT topic."),
-    sqlVersion: z23.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.")
-  })
-).optional().describe("Define the pubsub subscriber in your stack.");
-
 // src/feature/search/schema.ts
 import { gibibytes as gibibytes2 } from "@awsless/size";
 import { z as z24 } from "zod";
@@ -2035,13 +2052,13 @@ var hasOnFailure = (stacks) => {
 };
 
 // src/feature/function/build/typescript/bundle.ts
-import { rollup } from "rollup";
-import { createHash } from "crypto";
-import { swc, minify as swcMinify } from "rollup-plugin-swc3";
-import json from "@rollup/plugin-json";
 import commonjs from "@rollup/plugin-commonjs";
+import json from "@rollup/plugin-json";
 import nodeResolve from "@rollup/plugin-node-resolve";
+import { createHash } from "crypto";
 import { dirname as dirname5 } from "path";
+import { rollup } from "rollup";
+import { minify as swcMinify, swc } from "rollup-plugin-swc3";
 var bundleTypeScript = async ({ format: format2 = "esm", minify = true, file }) => {
   const bundle = await rollup({
     input: file,
@@ -3704,10 +3721,29 @@ import { aws as aws12, Node as Node11 } from "@awsless/formation";
 var pubsubFeature = defineFeature({
   name: "pubsub",
   onApp(ctx) {
+    for (const [id, props] of Object.entries(ctx.appConfig.defaults.realtime ?? {})) {
+      const group = new Node11(ctx.base, "pubsub", id);
+      const functionProps = typeof props.auth === "string" ? { file: "" } : props.auth.authorizer;
+      const { lambda } = createLambdaFunction(group, ctx, "pubsub-auth", id, functionProps);
+      lambda.addEnvironment("PUBSUB_POLICY", JSON.stringify(props.policy));
+      lambda.addEnvironment("AWS_ACCOUNT_ID", ctx.accountId);
+      const authorizer = new aws12.iot.Authorizer(group, "auth", {
+        name: "test",
+        functionArn: lambda.arn,
+        enableSigning: false
+      });
+      const permission = new aws12.lambda.Permission(group, "permission", {
+        functionArn: lambda.arn,
+        principal: "iot.amazonaws.com",
+        sourceArn: authorizer.arn,
+        action: "lambda:InvokeFunction"
+      });
+    }
     ctx.onPolicy((policy) => {
       policy.addStatement({
         actions: [`iot:Publish`],
         resources: [`arn:aws:iot:${ctx.appConfig.region}:${ctx.accountId}:topic/*`]
+        // resources: [`arn:aws:iot:${ctx.appConfig.region}:${ctx.accountId}:topic/${ctx.app.name}/*`],
       });
     });
   },
@@ -3932,8 +3968,9 @@ var searchFeature = defineFeature({
   onStack(ctx) {
     for (const [id, props] of Object.entries(ctx.stackConfig.searchs ?? {})) {
       const group = new Node14(ctx.stack, "search", id);
+      const name = `${id}-${shortId([ctx.app.name, ctx.stack.name, this.name, id].join("--"))}`;
       const openSearch = new aws15.openSearch.Domain(group, "domain", {
-        name: `${id}-${shortId([ctx.app.name, ctx.stack.name, this.name, id].join("--"))}`,
+        name,
         version: props.version,
         storageSize: props.storage,
         instance: {
@@ -3943,8 +3980,9 @@ var searchFeature = defineFeature({
         accessPolicy: {
           statements: [
             {
-              principal: "lambda.amazonaws.com",
-              sourceArn: `arn:aws:lambda:${ctx.appConfig.region}:${ctx.accountId}:function:${ctx.app.name}--${ctx.stack.name}--*`
+              principal: { AWS: "*" },
+              resources: [`arn:aws:es:${ctx.appConfig.region}:${ctx.accountId}:domain/${name}/*`],
+              principalArn: `arn:aws:iam::${ctx.accountId}:role/${ctx.app.name}--${ctx.stack.name}--*`
             }
           ]
         }
@@ -3961,7 +3999,7 @@ var searchFeature = defineFeature({
       ctx.addEnv(`SEARCH_${constantCase8(ctx.stack.name)}_${constantCase8(id)}_DOMAIN`, openSearch.domainEndpoint);
       ctx.onPolicy((policy) => {
         policy.addStatement({
-          actions: ["es:*"],
+          actions: ["es:ESHttp*"],
           resources: [openSearch.arn]
         });
       });

package/dist/build-json-schema.js

@@ -529,6 +529,22 @@ var OnFailureSchema = FunctionSchema.optional().describe(
 
 // src/feature/pubsub/schema.ts
 import { z as z17 } from "zod";
+var RealTimeDefaultSchema = z17.record(
+  ResourceIdSchema,
+  z17.object({
+    auth: z17.union([
+      ResourceIdSchema,
+      z17.object({
+        authorizer: FunctionSchema
+        // ttl: AuthorizerTtl.default('1 hour'),
+      })
+    ]),
+    policy: z17.object({
+      publish: z17.array(z17.string()).optional(),
+      subscribe: z17.array(z17.string()).optional()
+    })
+  })
+).optional().describe("Define the pubsub subscriber in your stack.");
 var PubSubSchema = z17.record(
   ResourceIdSchema,
   z17.object({
@@ -1097,7 +1113,8 @@ var AppSchema = z32.object({
     queue: QueueDefaultSchema,
     graphql: GraphQLDefaultSchema,
     http: HttpDefaultSchema,
-    rest: RestDefaultSchema
+    rest: RestDefaultSchema,
+    realtime: RealTimeDefaultSchema
   }).default({}).describe("Default properties")
 });
 

package/dist/client.d.ts

@@ -0,0 +1,54 @@
+interface AuthResources {
+}
+declare const Auth: AuthResources;
+declare const getAuthProps: (name: string) => {
+    readonly userPoolId: string;
+    readonly clientId: string;
+};
+
+interface GraphQLSchema {
+}
+interface GraphQLResources {
+}
+declare const GraphQL: GraphQLResources;
+declare const getGraphQLProps: (name: string) => {
+    endpoint: string;
+};
+
+interface HTTP {
+}
+type Method = 'GET' | 'POST';
+type Path = string;
+type Params = Record<string, string | number>;
+type Query = Record<string, string>;
+type Body = unknown;
+type Route = {
+    param?: Params;
+    query?: Query;
+    body?: Body;
+    response: unknown;
+};
+type Routes = Record<Path, Route>;
+type Schema = Partial<Record<Method, Routes>>;
+type GetRoute<S extends Schema, M extends keyof S, P extends keyof S[M]> = S[M] extends Routes ? S[M][P] : never;
+type Props<R extends Route> = {
+    headers?: Record<string, string>;
+    params?: R['param'] extends Params ? R['param'] : never;
+    query?: R['query'] extends Query ? R['query'] : never;
+    body?: R['body'] extends Body ? R['body'] : never;
+};
+type HttpFetcher = (props: {
+    method: Method;
+    path: Path;
+    headers: Headers;
+    query?: Query;
+    body?: Body;
+}) => unknown;
+declare const createHttpFetcher: (host: string) => HttpFetcher;
+declare const createHttpClient: <S extends Partial<Record<Method, Routes>>>(fetcher: HttpFetcher) => {
+    fetch: <M extends keyof S, P extends keyof S[M]>(method: M, routeKey: Extract<P, string>, props?: Props<GetRoute<S, M, P>> | undefined) => Promise<GetRoute<S, M, P>["response"]>;
+    get<P_1 extends keyof S["GET"]>(routeKey: Extract<P_1, string>, props?: Props<GetRoute<S, "GET", P_1>> | undefined): Promise<GetRoute<S, "GET", P_1>["response"]>;
+    post<P_2 extends keyof S["POST"]>(routeKey: Extract<P_2, string>, props?: Props<GetRoute<S, "POST", P_2>> | undefined): Promise<GetRoute<S, "POST", P_2>["response"]>;
+};
+
+export { Auth, AuthResources, GraphQL, GraphQLResources, GraphQLSchema, HTTP, HttpFetcher, createHttpClient, createHttpFetcher, getAuthProps, getGraphQLProps };

package/dist/server.d.ts

@@ -0,0 +1,101 @@
+import { AwsCredentialIdentityProvider } from '@aws-sdk/types';
+
+declare const regions: readonly ["us-east-2", "us-east-1", "us-west-1", "us-west-2", "af-south-1", "ap-east-1", "ap-south-2", "ap-southeast-3", "ap-southeast-4", "ap-south-1", "ap-northeast-3", "ap-northeast-2", "ap-southeast-1", "ap-southeast-2", "ap-northeast-1", "ca-central-1", "eu-central-1", "eu-west-1", "eu-west-2", "eu-south-1", "eu-west-3", "eu-south-2", "eu-north-1", "eu-central-2", "me-south-1", "me-central-1", "sa-east-1"];
+type Region = (typeof regions)[number];
+
+type Credentials = AwsCredentialIdentityProvider;
+
+type CommandContext = {
+    region: Region;
+    credentials: Credentials;
+    accountId: string;
+    update: (msg: string) => void;
+};
+type CommandHandler = (options: CommandOptions, context: CommandContext) => Promise<string | undefined | void>;
+declare class CommandOptions {
+    private opts;
+    constructor(args: string[]);
+    get(name: string): any;
+    private getAssertType;
+    number(name: string): number;
+    string(name: string): string;
+    boolean(name: string): boolean;
+}
+
+interface FunctionMock {
+}
+interface FunctionMockResponse {
+}
+declare const mockFunction: (cb: (mock: FunctionMock) => void) => FunctionMockResponse;
+
+interface QueueMock {
+}
+interface QueueMockResponse {
+}
+declare const mockQueue: (cb: (mock: QueueMock) => void) => QueueMockResponse;
+
+interface TaskMock {
+}
+interface TaskMockResponse {
+}
+declare const mockTask: (cb: (mock: TaskMock) => void) => TaskMockResponse;
+
+interface TopicMock {
+}
+interface TopicMockResponse {
+}
+declare const mockTopic: (cb: (mock: TopicMock) => void) => TopicMockResponse;
+
+declare const getCacheProps: (name: string, stack?: string) => {
+    readonly host: string;
+    readonly port: number;
+};
+interface CacheResources {
+}
+declare const Cache: CacheResources;
+
+declare const getConfigName: (name: string) => string;
+interface ConfigResources {
+}
+declare const Config: ConfigResources;
+
+declare const getFunctionName: <N extends string, S extends string = "stack">(name: N, stack?: S) => `app--${S}--function--${N}`;
+interface FunctionResources {
+}
+declare const Function: FunctionResources;
+declare const Fn: FunctionResources;
+
+declare const getQueueName: <N extends string, S extends string = "stack">(name: N, stack?: S) => `app--${S}--queue--${N}`;
+interface QueueResources {
+}
+declare const Queue: QueueResources;
+
+declare const getSearchName: <N extends string, S extends string = "stack">(name: N, stack?: S) => `app--${S}--search--${N}`;
+interface SearchResources {
+}
+declare const Search: SearchResources;
+
+declare const getStoreName: <N extends string, S extends string = "stack">(name: N, stack?: S) => `app--${S}--store--${N}`;
+interface StoreResources {
+}
+declare const Store: StoreResources;
+
+declare const getTableName: <N extends string, S extends string = "stack">(name: N, stack?: S) => `app--${S}--table--${N}`;
+interface TableResources {
+}
+declare const Table: TableResources;
+
+declare const getTaskName: <N extends string, S extends string = "stack">(name: N, stack?: S) => `app--${S}--task--${N}`;
+interface TaskResources {
+}
+declare const Task: TaskResources;
+
+declare const getTopicName: <N extends string>(name: N) => `app--topic--${N}`;
+interface TopicResources {
+}
+declare const Topic: TopicResources;
+
+declare const APP: "app";
+declare const STACK: "stack";
+
+export { APP, Cache, CacheResources, CommandContext, CommandHandler, CommandOptions, Config, ConfigResources, Fn, Function, FunctionMock, FunctionMockResponse, FunctionResources, Queue, QueueMock, QueueMockResponse, QueueResources, STACK, Search, SearchResources, Store, StoreResources, Table, TableResources, Task, TaskMock, TaskMockResponse, TaskResources, Topic, TopicMock, TopicMockResponse, TopicResources, getCacheProps, getConfigName, getFunctionName, getQueueName, getSearchName, getStoreName, getTableName, getTaskName, getTopicName, mockFunction, mockQueue, mockTask, mockTopic };