@awsless/awsless 0.0.35 → 0.0.36

package/dist/bin.js

@@ -998,7 +998,7 @@ var hasOnFailure = (config) => {
 };
 
 // src/plugins/function.ts
-import { camelCase, paramCase as paramCase3 } from "change-case";
+import { camelCase as camelCase2 } from "change-case";
 
 // src/util/path.ts
 import { lstat } from "fs/promises";
@@ -1048,7 +1048,95 @@ var fileExist = async (file) => {
 };
 
 // src/plugins/function.ts
-import { relative } from "path";
+import { relative as relative2 } from "path";
+
+// src/util/type-gen.ts
+import { mkdir, writeFile } from "fs/promises";
+import { join as join2, relative } from "path";
+import { camelCase } from "change-case";
+var generateResourceTypes = async (config) => {
+  const plugins = [
+    ...defaultPlugins,
+    ...config.plugins || []
+  ];
+  const files = [];
+  for (const plugin of plugins) {
+    const code = plugin.onTypeGen?.({ config });
+    if (code) {
+      const file = join2(directories.types, `${plugin.name}.d.ts`);
+      files.push(relative(directories.root, file));
+      await mkdir(directories.types, { recursive: true });
+      await writeFile(file, code);
+    }
+  }
+  if (files.length) {
+    const code = files.map((file) => `/// <reference path='${file}' />`).join("\n");
+    await writeFile(join2(directories.root, `awsless.d.ts`), code);
+  }
+};
+var TypeGen = class {
+  constructor(module, interfaceName) {
+    this.module = module;
+    this.interfaceName = interfaceName;
+  }
+  codes = /* @__PURE__ */ new Set();
+  types = /* @__PURE__ */ new Map();
+  imports = /* @__PURE__ */ new Map();
+  addImport(varName, path) {
+    this.imports.set(varName, path);
+    return this;
+  }
+  addCode(code) {
+    this.codes.add(code);
+    return this;
+  }
+  addType(name, type) {
+    if (type) {
+      this.types.set(name, type);
+    }
+    return this;
+  }
+  toString() {
+    if (this.types.size === 0) {
+      return;
+    }
+    const imports = Array.from(this.imports.entries()).map(([varName, path]) => {
+      return `import ${camelCase(varName)} from '${path}'`;
+    }).join("\n");
+    return [
+      imports,
+      ...Array.from(this.codes),
+      `declare module '${this.module}' {`,
+      `	interface ${this.interfaceName} {`,
+      ...Array.from(this.types.entries()).map(([propName, type]) => {
+        return `		readonly ${camelCase(propName)}: ${type}`;
+      }),
+      `	}`,
+      `}`
+    ].join("\n");
+  }
+};
+var TypeObject = class {
+  types = /* @__PURE__ */ new Map();
+  addType(name, type) {
+    this.types.set(name, type);
+    return this;
+  }
+  toString() {
+    if (!this.types.size) {
+      return "";
+    }
+    return [
+      "{",
+      ...Array.from(this.types.entries()).map(([propName, type]) => {
+        return `			readonly ${camelCase(propName)}: ${type}`;
+      }),
+      "		}"
+    ].join("\n");
+  }
+};
+
+// src/plugins/function.ts
 var MemorySizeSchema = SizeSchema.refine(sizeMin(Size.megaBytes(128)), "Minimum memory size is 128 MB").refine(sizeMax(Size.gigaBytes(10)), "Minimum memory size is 10 GB");
 var TimeoutSchema = DurationSchema.refine(durationMin(Duration.seconds(10)), "Minimum timeout duration is 10 seconds").refine(durationMax(Duration.minutes(15)), "Maximum timeout duration is 15 minutes");
 var EphemeralStorageSizeSchema = SizeSchema.refine(sizeMin(Size.megaBytes(512)), "Minimum ephemeral storage size is 512 MB").refine(sizeMax(Size.gigaBytes(10)), "Minimum ephemeral storage size is 10 GB");
@@ -1183,51 +1271,33 @@ var schema = z6.object({
     ).optional()
   }).array()
 });
+var typeGenCode = `
+import { InvokeOptions } from '@awsless/lambda'
+
+type Invoke<Name extends string, Func extends (...args: any[]) => any> = {
+	name: Name
+	invoke: (event: Parameters<Func>[0], options?: Omit<InvokeOptions, 'name' | 'payload'>) => ReturnType<Func>
+	async: (event: Parameters<Func>[0], options?: Omit<InvokeOptions, 'name' | 'payload' | 'type'>) => ReturnType<Func>
+}`;
 var functionPlugin = definePlugin({
   name: "function",
   schema,
   onTypeGen({ config }) {
-    const imports = [];
-    const props = [];
+    const types2 = new TypeGen("@awsless/awsless", "FunctionResources");
+    types2.addCode(typeGenCode);
     for (const stack of config.stacks) {
-      const functions = [];
+      const list3 = new TypeObject();
       for (const [name, fileOrProps] of Object.entries(stack.functions || {})) {
-        const varName = camelCase(`${stack.name}-${name}`);
-        const funcName = paramCase3(`${config.name}-${stack.name}--${name}`);
+        const varName = camelCase2(`${stack.name}-${name}`);
+        const funcName = formatName(`${config.name}-${stack.name}-${name}`);
         const file = typeof fileOrProps === "string" ? fileOrProps : fileOrProps.file;
-        const relFile = relative(directories.types, file);
-        imports.push(`import ${varName} from '${relFile}'`);
-        functions.push(`			readonly ${camelCase(name)}: Invoke<'${funcName}', typeof ${varName}>`);
+        const relFile = relative2(directories.types, file);
+        types2.addImport(varName, relFile);
+        list3.addType(name, `Invoke<'${funcName}', typeof ${varName}>`);
       }
-      if (functions.length > 0) {
-        props.push(`		readonly ${camelCase(stack.name)}: {
- ${functions.join("\n")}
-		}`);
-      }
-    }
-    if (imports.length === 0) {
-      return;
+      types2.addType(stack.name, list3.toString());
     }
-    return (
-      /* TS */
-      `
-${imports.join("\n")}
-
-import { InvokeOptions } from '@awsless/lambda'
-
-type Options = Omit<InvokeOptions, 'name' | 'payload'>
-
-type Invoke<Name extends string, Func extends (...args: any[]) => any> = {
-	name: Name
-	invoke: (event: Parameters<Func>[0], options?: Options) => ReturnType<Func>
-}
-
-declare module '@awsless/awsless' {
-	interface FunctionResources {
-${props.join("\n")}
-	}
-}`
-    );
+    return types2.toString();
   },
   onStack(ctx) {
     const { config, stack } = ctx;
@@ -1628,6 +1698,18 @@ var queuePlugin = definePlugin({
       ).optional()
     }).array()
   }),
+  onTypeGen({ config }) {
+    const types2 = new TypeGen("@awsless/awsless", "QueueResources");
+    for (const stack of config.stacks) {
+      const list3 = new TypeObject();
+      for (const name of Object.keys(stack.queues || {})) {
+        const queueName = formatName(`${config.name}-${stack.name}-${name}`);
+        list3.addType(name, `{ name: '${queueName}' }`);
+      }
+      types2.addType(stack.name, list3.toString());
+    }
+    return types2.toString();
+  },
   onStack(ctx) {
     const { stack, config, stackConfig, bind } = ctx;
     for (const [id, functionOrProps] of Object.entries(stackConfig.queues || {})) {
@@ -1901,6 +1983,18 @@ var tablePlugin = definePlugin({
       ).optional()
     }).array()
   }),
+  onTypeGen({ config }) {
+    const types2 = new TypeGen("@awsless/awsless", "TableResources");
+    for (const stack of config.stacks) {
+      const list3 = new TypeObject();
+      for (const name of Object.keys(stack.tables || {})) {
+        const tableName = formatName(`${config.name}-${stack.name}-${name}`);
+        list3.addType(name, `{ name: '${tableName}' }`);
+      }
+      types2.addType(stack.name, list3.toString());
+    }
+    return types2.toString();
+  },
   onStack(ctx) {
     const { config, stack, stackConfig, bind } = ctx;
     for (const [id, props] of Object.entries(stackConfig.tables || {})) {
@@ -2087,6 +2181,16 @@ var topicPlugin = definePlugin({
       topics: z11.record(ResourceIdSchema, FunctionSchema).optional()
     }).array()
   }),
+  onTypeGen({ config }) {
+    const gen = new TypeGen("@awsless/awsless", "TopicResources");
+    for (const stack of config.stacks) {
+      for (const topic of Object.keys(stack.topics || {})) {
+        const name = formatName(`${config.name}-${topic}`);
+        gen.addType(topic, `{ name: '${name}' }`);
+      }
+    }
+    return gen.toString();
+  },
   onApp({ config, bootstrap: bootstrap2, bind }) {
     const allTopicNames = config.stacks.map((stack) => {
       return Object.keys(stack.topics || {});
@@ -2251,7 +2355,7 @@ var toArray = (value) => {
 };
 
 // src/plugins/graphql.ts
-import { paramCase as paramCase4 } from "change-case";
+import { paramCase as paramCase3 } from "change-case";
 
 // src/formation/resource/appsync/graphql-api.ts
 import { constantCase as constantCase3 } from "change-case";
@@ -2684,7 +2788,7 @@ var graphqlPlugin = definePlugin({
       const apiId = bootstrap2.import(`graphql-${id}`);
       for (const [typeAndField, functionProps] of Object.entries(props.resolvers || {})) {
         const [typeName, fieldName] = typeAndField.split(/[\s]+/g);
-        const entryId = paramCase4(`${id}-${typeName}-${fieldName}`);
+        const entryId = paramCase3(`${id}-${typeName}-${fieldName}`);
         const lambda = toLambdaFunction(ctx, `graphql-${entryId}`, functionProps);
         const source = new AppsyncEventSource(entryId, lambda, {
           apiId,
@@ -4141,7 +4245,7 @@ var toApp = async (config, filters) => {
 };
 
 // src/config.ts
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // src/util/account.ts
 import { STSClient, GetCallerIdentityCommand } from "@aws-sdk/client-sts";
@@ -4225,11 +4329,12 @@ var AppSchema = z23.object({
 });
 
 // src/util/import.ts
-import { rollup as rollup2 } from "rollup";
+import { rollup as rollup2, watch } from "rollup";
 import { swc as swc2 } from "rollup-plugin-swc3";
 import replace from "rollup-plugin-replace";
-import { dirname as dirname2, join as join2 } from "path";
-import { mkdir, writeFile } from "fs/promises";
+import { EventIterator } from "event-iterator";
+import { dirname as dirname2, join as join3 } from "path";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 var importFile = async (path) => {
   const bundle = await rollup2({
     input: path,
@@ -4248,18 +4353,73 @@ var importFile = async (path) => {
       })
     ]
   });
-  const outputFile = join2(directories.cache, "config.js");
+  const outputFile = join3(directories.cache, "config.js");
   const result = await bundle.generate({
     format: "esm",
     exports: "default"
   });
   const output = result.output[0];
   const code = output.code;
-  await mkdir(directories.cache, { recursive: true });
-  await writeFile(outputFile, code);
+  await mkdir2(directories.cache, { recursive: true });
+  await writeFile2(outputFile, code);
   debug("Save config file:", style.info(outputFile));
   return import(outputFile);
 };
+var watchFile = (path) => {
+  return new EventIterator((queue2) => {
+    const watcher = watch({
+      watch: {
+        skipWrite: true
+      },
+      input: path,
+      onwarn: (error) => {
+        debugError(error.message);
+      },
+      plugins: [
+        replace({
+          __dirname: (id) => `'${dirname2(id)}'`
+        }),
+        swc2({
+          minify: false,
+          jsc: {
+            baseUrl: dirname2(path)
+          }
+        })
+      ]
+    });
+    let resume;
+    queue2.on("lowWater", () => {
+      resume?.(true);
+    });
+    watcher.on("close", queue2.stop);
+    watcher.on("event", async (event) => {
+      if (event.code === "ERROR") {
+        queue2.fail(new Error(event.error.message));
+      }
+      if (event.code === "BUNDLE_END") {
+        const result = await event.result.generate({
+          format: "esm",
+          exports: "default"
+        });
+        event.result.close();
+        const output = result.output[0];
+        const code = output.code;
+        const outputFile = join3(directories.cache, "config.js");
+        await mkdir2(directories.cache, { recursive: true });
+        await writeFile2(outputFile, code);
+        debug("Save config file:", style.info(outputFile));
+        const config = await import(`${outputFile}?${Date.now()}`);
+        queue2.push(config);
+      }
+    });
+    return () => {
+      watcher.close();
+    };
+  }, {
+    highWaterMark: 1,
+    lowWaterMark: 0
+  });
+};
 
 // src/config.ts
 var importConfig = async (options) => {
@@ -4269,7 +4429,7 @@ var importConfig = async (options) => {
   setRoot(root2);
   debug("CWD:", style.info(root2));
   debug("Import config file");
-  const fileName = join3(root2, configFile);
+  const fileName = join4(root2, configFile);
   const module = await importFile(fileName);
   const appConfig = typeof module.default === "function" ? await module.default(options) : module.default;
   debug("Validate config file");
@@ -4295,6 +4455,40 @@ var importConfig = async (options) => {
     credentials
   };
 };
+var watchConfig = async function* (options) {
+  debug("Find the root directory");
+  const configFile = options.configFile || "awsless.config.ts";
+  const root2 = await findRootDir(process.cwd(), configFile);
+  setRoot(root2);
+  debug("CWD:", style.info(root2));
+  debug("Import config file");
+  const fileName = join4(root2, configFile);
+  for await (const module of watchFile(fileName)) {
+    const appConfig = typeof module.default === "function" ? await module.default(options) : module.default;
+    debug("Validate config file");
+    const plugins = [
+      ...defaultPlugins,
+      ...appConfig.plugins || []
+    ];
+    let schema2 = AppSchema;
+    for (const plugin of plugins) {
+      if (plugin.schema) {
+        schema2 = schema2.and(plugin.schema);
+      }
+    }
+    const config = await schema2.parseAsync(appConfig);
+    debug("Load credentials", style.info(config.profile));
+    const credentials = getCredentials(config.profile);
+    debug("Load AWS account ID");
+    const account = await getAccountId(credentials, config.region);
+    debug("Account ID:", style.info(account));
+    yield {
+      ...config,
+      account,
+      credentials
+    };
+  }
+};
 
 // src/cli/ui/layout/basic.ts
 var br = () => {
@@ -4770,7 +4964,7 @@ var layout = async (cb) => {
 };
 
 // src/cli/ui/complex/builder.ts
-import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
 
 // src/cli/ui/layout/flex-line.ts
 var stripEscapeCode = (str) => {
@@ -4793,7 +4987,7 @@ var flexLine = (term, left, right, reserveSpace = 0) => {
 };
 
 // src/cli/ui/complex/builder.ts
-import { dirname as dirname3, join as join4 } from "path";
+import { dirname as dirname3, join as join5 } from "path";
 var assetBuilder = (app) => {
   return async (term) => {
     const assets = [];
@@ -4856,10 +5050,10 @@ var assetBuilder = (app) => {
         try {
           const data = await asset.build({
             async write(file, data2) {
-              const fullpath = join4(directories.asset, asset.type, app.name, stack.name, asset.id, file);
+              const fullpath = join5(directories.asset, asset.type, app.name, stack.name, asset.id, file);
               const basepath = dirname3(fullpath);
-              await mkdir2(basepath, { recursive: true });
-              await writeFile2(fullpath, data2);
+              await mkdir3(basepath, { recursive: true });
+              await writeFile3(fullpath, data2);
             }
           });
           details.set({
@@ -4883,7 +5077,7 @@ var assetBuilder = (app) => {
 };
 
 // src/util/cleanup.ts
-import { mkdir as mkdir3, rm } from "fs/promises";
+import { mkdir as mkdir4, rm } from "fs/promises";
 var cleanUp = async () => {
   debug("Clean up template, cache, and asset files");
   const paths = [
@@ -4897,52 +5091,28 @@ var cleanUp = async () => {
     force: true,
     maxRetries: 2
   })));
-  await Promise.all(paths.map((path) => mkdir3(path, {
+  await Promise.all(paths.map((path) => mkdir4(path, {
     recursive: true
   })));
 };
 
 // src/cli/ui/complex/template.ts
-import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
-import { join as join5 } from "path";
+import { mkdir as mkdir5, writeFile as writeFile4 } from "fs/promises";
+import { join as join6 } from "path";
 var templateBuilder = (app) => {
   return async (term) => {
     const done = term.out.write(loadingDialog("Building stack templates..."));
     await Promise.all(app.stacks.map(async (stack) => {
       const template = stack.toString(true);
-      const path = join5(directories.template, app.name);
-      const file = join5(path, `${stack.name}.json`);
-      await mkdir4(path, { recursive: true });
-      await writeFile3(file, template);
+      const path = join6(directories.template, app.name);
+      const file = join6(path, `${stack.name}.json`);
+      await mkdir5(path, { recursive: true });
+      await writeFile4(file, template);
     }));
     done("Done building stack templates");
   };
 };
 
-// src/util/type-gen.ts
-import { mkdir as mkdir5, writeFile as writeFile4 } from "fs/promises";
-import { join as join6, relative as relative2 } from "path";
-var generateResourceTypes = async (config) => {
-  const plugins = [
-    ...defaultPlugins,
-    ...config.plugins || []
-  ];
-  const files = [];
-  for (const plugin of plugins) {
-    const code = plugin.onTypeGen?.({ config });
-    if (code) {
-      const file = join6(directories.types, `${plugin.name}.d.ts`);
-      files.push(relative2(directories.root, file));
-      await mkdir5(directories.types, { recursive: true });
-      await writeFile4(file, code);
-    }
-  }
-  if (files.length) {
-    const code = files.map((file) => `import '${file}';`).join("\n");
-    await writeFile4(join6(directories.root, `awsless.d.ts`), code);
-  }
-};
-
 // src/cli/ui/complex/types.ts
 var typesGenerator = (config) => {
   return async (term) => {
@@ -4995,7 +5165,7 @@ var shouldDeployBootstrap = async (client, stack) => {
 // src/formation/client.ts
 import { CloudFormationClient, CreateStackCommand, DeleteStackCommand, DescribeStackEventsCommand, DescribeStacksCommand, GetTemplateCommand, OnFailure, TemplateStage, UpdateStackCommand, ValidateTemplateCommand, waitUntilStackCreateComplete, waitUntilStackDeleteComplete, waitUntilStackUpdateComplete } from "@aws-sdk/client-cloudformation";
 import { S3Client, PutObjectCommand, ObjectCannedACL, StorageClass } from "@aws-sdk/client-s3";
-import { paramCase as paramCase5 } from "change-case";
+import { paramCase as paramCase4 } from "change-case";
 var StackClient = class {
   constructor(app, account, region, credentials) {
     this.app = app;
@@ -5028,7 +5198,7 @@ var StackClient = class {
     };
   }
   stackName(stackName) {
-    return paramCase5(`${this.app.name}-${stackName}`);
+    return paramCase4(`${this.app.name}-${stackName}`);
   }
   tags(stack) {
     const tags = [];
@@ -5734,6 +5904,19 @@ var types = (program2) => {
   });
 };
 
+// src/cli/command/dev.ts
+var dev = (program2) => {
+  program2.command("dev").description("Start the development service").action(async () => {
+    await layout(async (_, write) => {
+      const options = program2.optsWithGlobals();
+      for await (const config of watchConfig(options)) {
+        await cleanUp();
+        await write(typesGenerator(config));
+      }
+    });
+  });
+};
+
 // src/cli/program.ts
 var program = new Command();
 program.name(logo().join("").replace(/\s+/, ""));
@@ -5755,6 +5938,7 @@ var commands2 = [
   types,
   build,
   deploy,
+  dev,
   secrets,
   test
   // diff,

package/dist/index.cjs

@@ -21,7 +21,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   Function: () => Function,
+  Queue: () => Queue,
   Table: () => Table,
+  Topic: () => Topic,
   defineAppConfig: () => defineAppConfig,
   definePlugin: () => definePlugin,
   defineStackConfig: () => defineStackConfig,
@@ -53,8 +55,6 @@ var getGlobalResourceName = (name) => {
 };
 var getSearchName = getLocalResourceName;
 var getStoreName = getLocalResourceName;
-var getQueueName = getLocalResourceName;
-var getTopicName = getGlobalResourceName;
 var getSecretName = (name) => {
   return `/.awsless/${APP}/${name}`;
 };
@@ -86,14 +86,26 @@ var createProxy = (cb) => {
 var getFunctionName = (stack, name) => {
   return getLocalResourceName(name, stack);
 };
-var Function = createProxy((stack) => {
-  return createProxy((name) => {
-    return (event, options = {}) => {
-      return (0, import_lambda.invoke)({
-        ...options,
-        name: getFunctionName(stack, name),
-        payload: event
-      });
+var Function = createProxy((stackName) => {
+  return createProxy((funcName) => {
+    const name = getFunctionName(stackName, funcName);
+    return {
+      name,
+      invoke(payload, options = {}) {
+        return (0, import_lambda.invoke)({
+          ...options,
+          name,
+          payload
+        });
+      },
+      async(payload, options = {}) {
+        return (0, import_lambda.invoke)({
+          ...options,
+          name,
+          payload,
+          type: "Event"
+        });
+      }
     };
   });
 });
@@ -102,7 +114,33 @@ var Function = createProxy((stack) => {
 var getTableName = getLocalResourceName;
 var Table = createProxy((stack) => {
   return createProxy((name) => {
-    return getTableName(name, stack);
+    return {
+      name: getTableName(name, stack)
+    };
+  });
+});
+
+// src/node/topic.ts
+var getTopicName = getGlobalResourceName;
+var Topic = createProxy((topic) => {
+  const name = getTopicName(topic);
+  return {
+    name
+    // publish(payload:unknown) {
+    // }
+  };
+});
+
+// src/node/queue.ts
+var getQueueName = getLocalResourceName;
+var Queue = createProxy((stack) => {
+  return createProxy((queue) => {
+    const name = getQueueName(queue, stack);
+    return {
+      name
+      // sendMessage(payload:unknown) {
+      // }
+    };
   });
 });
 
@@ -116,7 +154,9 @@ var defineAppConfig = (config) => {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Function,
+  Queue,
   Table,
+  Topic,
   defineAppConfig,
   definePlugin,
   defineStackConfig,

package/dist/index.d.ts

@@ -2474,8 +2474,6 @@ declare const getLocalResourceName: <N extends string, S extends string = "stack
 declare const getGlobalResourceName: <N extends string>(name: N) => `app-${N}`;
 declare const getSearchName: <N extends string, S extends string = "stack">(name: N, stack?: S) => `app-${S}-${N}`;
 declare const getStoreName: <N extends string, S extends string = "stack">(name: N, stack?: S) => `app-${S}-${N}`;
-declare const getQueueName: <N extends string, S extends string = "stack">(name: N, stack?: S) => `app-${S}-${N}`;
-declare const getTopicName: <N extends string>(name: N) => `app-${N}`;
 declare const getSecretName: (name: string) => string;
 declare const getCacheProps: (name: string, stack?: "stack") => {
     readonly host: string;
@@ -2492,6 +2490,16 @@ interface TableResources {
 }
 declare const Table: TableResources;
 
+declare const getTopicName: <N extends string>(name: N) => `app-${N}`;
+interface TopicResources {
+}
+declare const Topic: {};
+
+declare const getQueueName: <N extends string, S extends string = "stack">(name: N, stack?: S) => `app-${S}-${N}`;
+interface QueueResources {
+}
+declare const Queue: {};
+
 type AppConfig = CombinedDefaultPluginsConfigInput;
 type StackConfig = CombinedDefaultPluginsConfigInput['stacks'][number];
 declare const defineStackConfig: (config: StackConfig) => StackConfig$1 | (StackConfig$1 & {
@@ -2710,4 +2718,4 @@ declare const defineStackConfig: (config: StackConfig) => StackConfig$1 | (Stack
 });
 declare const defineAppConfig: (config: AppConfig | AppConfigFactory<AppConfig>) => CombinedDefaultPluginsConfigInput | AppConfigFactory<CombinedDefaultPluginsConfigInput>;
 
-export { AppConfig, Function, FunctionResources, Plugin, StackConfig, Table, defineAppConfig, definePlugin, defineStackConfig, getCacheProps, getFunctionName, getGlobalResourceName, getLocalResourceName, getQueueName, getSearchName, getSecretName, getStoreName, getTableName, getTopicName };
+export { AppConfig, Function, FunctionResources, Plugin, Queue, QueueResources, StackConfig, Table, TableResources, Topic, TopicResources, defineAppConfig, definePlugin, defineStackConfig, getCacheProps, getFunctionName, getGlobalResourceName, getLocalResourceName, getQueueName, getSearchName, getSecretName, getStoreName, getTableName, getTopicName };