@sst-community/sst 4.21.1 → 5.0.0-alpha.2

package/platform/types/components/aws/workflow.d.ts

@@ -0,0 +1,331 @@
+import { ComponentResourceOptions, Input } from "@pulumi/pulumi";
+import { Duration, DurationDays, DurationMinutes } from "../duration.js";
+import { Component } from "../component.js";
+import { RETENTION } from "./logging.js";
+import { Function, FunctionArgs } from "./function.js";
+export interface WorkflowArgs extends Omit<FunctionArgs, "concurrency" | "durable" | "injections" | "live" | "logging" | "retries" | "runtime" | "streaming" | "timeout" | "transform" | "url" | "versioning" | "_skipHint" | "_skipMetadata"> {
+    /**
+     * The language runtime for the workflow.
+     *
+     * AWS Lambda durable functions currently support `"nodejs22.x"`, `"nodejs24.x"`, and
+     * `"python3.13"`.
+     *
+     * @default `"nodejs24.x"`
+     * @example
+     * ```js
+     * {
+     *   runtime: "python3.13"
+     * }
+     * ```
+     */
+    runtime?: Input<"nodejs22.x" | "nodejs24.x" | "python3.13">;
+    /**
+     * Number of days to retain the workflow execution state.
+     *
+     * @default `"30 days"`
+     */
+    retention?: Input<DurationDays>;
+    /**
+     * Configure timeout limits for the workflow execution and each underlying Lambda invocation.
+     */
+    timeout?: Input<{
+        /**
+         * Maximum execution time for the entire workflow execution, from when it starts until it completes.
+         *
+         * This includes time spent across retries, replays, waits, and all durable invocations.
+         *
+         * @default `"14 days"`
+         */
+        execution?: Input<Duration>;
+        /**
+         * Maximum execution time for each underlying Lambda invocation.
+         *
+         * This is not a per-step timeout. A single invocation can run multiple steps before the
+         * workflow yields, waits, or replays.
+         *
+         * @default `"5 minutes"`
+         */
+        invocation?: Input<DurationMinutes>;
+    }>;
+    /**
+     * Configure the workflow logs in CloudWatch. Or pass in `false` to disable writing logs.
+     * The only supported log format is `json`.
+     *
+     * @default `{retention: "1 month", format: "json"}`
+     */
+    logging?: false | {
+        /**
+         * The log format for the workflow.
+         *
+         * AWS Lambda durable functions require structured JSON logs, so `"json"` is the only
+         * supported value.
+         *
+         * @default `"json"`
+         */
+        format?: Input<"json">;
+        /**
+         * The duration the workflow logs are kept in CloudWatch.
+         *
+         * Not applicable when an existing log group is provided.
+         *
+         * @default `1 month`
+         * @example
+         * ```js
+         * {
+         *   logging: {
+         *     retention: "forever"
+         *   }
+         * }
+         * ```
+         */
+        retention?: Input<keyof typeof RETENTION>;
+        /**
+         * Assigns the given CloudWatch log group name to the workflow. This allows you to
+         * pass in a previously created log group.
+         *
+         * By default, the workflow creates a new log group when it's created.
+         *
+         * @default Creates a log group
+         * @example
+         * ```js
+         * {
+         *   logging: {
+         *     logGroup: "/existing/log-group"
+         *   }
+         * }
+         * ```
+         */
+        logGroup?: Input<string>;
+    };
+    /**
+     * [Transform](/docs/components#transform) how this component creates its underlying resources.
+     */
+    transform?: {
+        /**
+         * Transform the underlying SST Function component resources.
+         */
+        function?: FunctionArgs["transform"];
+    };
+}
+/**
+ * The `Workflow` component lets you add serverless workflows to your app using
+ * [AWS Lambda Durable Functions](https://docs.aws.amazon.com/lambda/latest/dg/durable-functions.html).
+ *
+ * It's a thin wrapper around the [`Function`](/docs/component/aws/function) component
+ * with durable execution enabled.
+ * It includes an [SDK](/docs/components/aws/workflow/#sdk) that wraps the AWS SDK with a simpler interface, adds helper methods, and makes it easier to integrate with other SST components.
+ *
+ * @example
+ *
+ * #### Minimal example
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.Workflow("MyWorkflow", {
+ *   handler: "src/workflow.handler",
+ * });
+ * ```
+ *
+ * ```ts title="src/workflow.ts"
+ * import { workflow } from "sst/aws/workflow";
+ *
+ * export const handler = workflow.handler(async (event, ctx) => {
+ *   const user = await ctx.step("load-user", async () => {
+ *     return { id: "user_123", email: "alice@example.com" };
+ *   });
+ *
+ *   await ctx.wait("pause-before-email", "1 minute");
+ *
+ *   return ctx.step("send-email", async () => {
+ *     return { sent: true, userId: user.id };
+ *   });
+ * });
+ * ```
+ *
+ * #### Configure timeout and retention
+ *
+ * ```ts {3-7} title="sst.config.ts"
+ * new sst.aws.Workflow("MyWorkflow", {
+ *   handler: "src/workflow.handler",
+ *   retention: "30 days",
+ *   timeout: {
+ *     execution: "2 hours",
+ *     invocation: "30 seconds",
+ *   },
+ * });
+ * ```
+ *
+ * #### Link resources
+ *
+ * ```ts {1,5} title="sst.config.ts"
+ * const bucket = new sst.aws.Bucket("MyBucket");
+ *
+ * new sst.aws.Workflow("MyWorkflow", {
+ *   handler: "src/workflow.handler",
+ *   link: [bucket],
+ * });
+ * ```
+ *
+ * ```ts title="src/workflow.ts"
+ * import { Resource } from "sst";
+ * import { workflow } from "sst/aws/workflow";
+ *
+ * export const handler = workflow.handler(async (event, ctx) => {
+ *   return ctx.step("get-bucket-name", async () => {
+ *     return Resource.MyBucket.name;
+ *   });
+ * });
+ * ```
+ *
+ * #### Trigger with a cron job
+ *
+ * ```ts {5-8} title="sst.config.ts"
+ * const workflow = new sst.aws.Workflow("MyWorkflow", {
+ *   handler: "src/workflow.handler",
+ * });
+ *
+ * new sst.aws.CronV2("MyCron", {
+ *   schedule: "rate(1 minute)",
+ *   function: workflow,
+ * });
+ * ```
+ *
+ * ```ts title="src/workflow.ts"
+ * import { workflow } from "sst/aws/workflow";
+ *
+ * export const handler = workflow.handler(async (event, ctx) => {
+ *   await ctx.step("start", async ({ logger }) => {
+ *     logger.info({ message: "Workflow invoked by cron" });
+ *   });
+ * });
+ * ```
+ *
+ * [Check out the full example](/docs/examples/#aws-workflow-cron).
+ *
+ * #### Subscribe to a bus
+ *
+ * ```ts {6-9} title="sst.config.ts"
+ * const workflow = new sst.aws.Workflow("MyWorkflow", {
+ *   handler: "src/workflow.handler",
+ * });
+ *
+ * const bus = new sst.aws.Bus("MyBus");
+ *
+ * bus.subscribe("MySubscriber", workflow, {
+ *   pattern: {
+ *     detailType: ["app.workflow.requested"],
+ *   },
+ * });
+ * ```
+ *
+ * ```ts title="src/workflow.ts"
+ * import { workflow } from "sst/aws/workflow";
+ *
+ * interface Event {
+ *   "detail-type": string;
+ *   detail: {
+ *     properties: {
+ *       message: string;
+ *       requestId: string;
+ *     };
+ *   };
+ * }
+ *
+ * export const handler = workflow.handler<Event>(async (event, ctx) => {
+ *   await ctx.step("start", async ({ logger }) => {
+ *     logger.info({
+ *       message: "Workflow invoked by bus",
+ *       requestId: event.detail.properties.requestId,
+ *     });
+ *   });
+ * });
+ * ```
+ *
+ * [Check out the full example](/docs/examples/#aws-workflow-bus).
+ *
+ * ---
+ *
+ * ### Limitations
+ *
+ * Durable workflows replay from the top on resume and retry. Keep the control flow
+ * deterministic, and move side effects like API calls, database writes, timestamps, and random
+ * ID generation inside durable operations like `ctx.step()`.
+ *
+ * :::caution
+ * Workflow handlers have versioning enabled. Deploying an update won't update existing running workflows.
+ * :::
+ *
+ * Before using workflows in production, review the
+ * [AWS best practices for durable functions](https://docs.aws.amazon.com/lambda/latest/dg/durable-best-practices.html).
+ *
+ * ---
+ *
+ * ### Cost
+ *
+ * A workflow has no idle monthly cost. You pay the standard Lambda request and compute charges
+ * for each invocation.
+ *
+ * :::tip
+ * When a workflow is suspended in a `wait`, functions don't incur costs until execution resumes.
+ * :::
+ *
+ * Lambda durable functions usage is billed separately.
+ *
+ * - Durable operations like starting an execution, completing a step, and creating a wait are
+ *   billed at $8.00 per 1 million operations.
+ * - Data written by durable operations is billed at $0.25 per GB.
+ * - Retained execution state is billed at $0.15 per GB-month.
+ *
+ * For example, a workflow with two `step()` calls and one `wait()` uses four durable operations:
+ * one start, two steps, and one wait. That's about **$0.000032 per execution** for durable
+ * operations, before Lambda compute, requests, written data, and retention.
+ *
+ * These are rough _us-east-1_ estimates. Check out the
+ * [AWS Lambda pricing](https://aws.amazon.com/lambda/pricing/#Lambda_Durable_Functions_Pricing)
+ * for more details.
+ */
+export declare class Workflow extends Component {
+    private readonly fn;
+    constructor(name: string, args: WorkflowArgs, opts?: ComponentResourceOptions);
+    /** @internal */
+    getFunction(): Function;
+    /**
+     * The underlying [resources](/docs/components/#nodes) this component creates.
+     */
+    get nodes(): {
+        /**
+         * The SST Function component backing the workflow.
+         */
+        function: Function;
+    };
+    /**
+     * The name of the Lambda function backing the workflow.
+     */
+    get name(): import("@pulumi/pulumi").Output<string>;
+    /**
+     * The ARN of the Lambda function backing the workflow.
+     */
+    get arn(): import("@pulumi/pulumi").Output<string>;
+    /**
+     * The published version qualifier backing the workflow.
+     */
+    get qualifier(): import("@pulumi/pulumi").Output<string | undefined>;
+    /** @internal */
+    getSSTLink(): {
+        properties: {
+            name: import("@pulumi/pulumi").Output<string>;
+            qualifier: import("@pulumi/pulumi").Output<string | undefined>;
+        };
+        include: {
+            effect?: "allow" | "deny" | undefined;
+            actions: string[];
+            resources: import("../input.js").Input<import("../input.js").Input<string>[]>;
+            conditions?: import("../input.js").Input<import("../input.js").Input<{
+                test: import("../input.js").Input<string>;
+                variable: import("../input.js").Input<string>;
+                values: import("../input.js").Input<import("../input.js").Input<string>[]>;
+            }>[]> | undefined;
+            type: "aws.permission";
+        }[];
+    };
+}
+//# sourceMappingURL=workflow.d.ts.map

package/platform/types/components/aws/workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../../../src/components/aws/workflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,KAAK,EAAU,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAEvD,MAAM,WAAW,YACf,SAAQ,IAAI,CACV,YAAY,EACV,aAAa,GACb,SAAS,GACT,YAAY,GACZ,MAAM,GACN,SAAS,GACT,SAAS,GACT,SAAS,GACT,WAAW,GACX,SAAS,GACT,WAAW,GACX,KAAK,GACL,YAAY,GACZ,WAAW,GACX,eAAe,CAClB;IACD;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,YAAY,GAAG,YAAY,GAAG,YAAY,CAAC,CAAC;IAC5D;;;;OAIG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;IAChC;;OAEG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC;QACd;;;;;;WAMG;QACH,SAAS,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;QAC5B;;;;;;;WAOG;QACH,UAAU,CAAC,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;KACrC,CAAC,CAAC;IACH;;;;;OAKG;IACH,OAAO,CAAC,EACJ,KAAK,GACL;QACE;;;;;;;WAOG;QACH,MAAM,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QACvB;;;;;;;;;;;;;;WAcG;QACH,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;QAC1C;;;;;;;;;;;;;;;WAeG;QACH,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;KAC1B,CAAC;IACN;;OAEG;IACH,SAAS,CAAC,EAAE;QACV;;WAEG;QACH,QAAQ,CAAC,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC;KACtC,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+KG;AACH,qBAAa,QAAS,SAAQ,SAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAW;gBAG5B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,YAAY,EAClB,IAAI,CAAC,EAAE,wBAAwB;IAuDjC,gBAAgB;IACT,WAAW;IAIlB;;OAEG;IACH,IAAW,KAAK;QAEZ;;WAEG;;MAGN;IAED;;OAEG;IACH,IAAW,IAAI,4CAEd;IAED;;OAEG;IACH,IAAW,GAAG,4CAEb;IAED;;OAEG;IACH,IAAW,SAAS,wDAEnB;IAED,gBAAgB;IACT,UAAU;;;;;;;;;;;;;;;;;CAUlB"}

package/platform/types/components/base/base-site.d.ts

@@ -0,0 +1,53 @@
+import { Input } from "../input";
+export interface BaseSiteDev {
+    /**
+     * The `url` when this is running in dev mode.
+     *
+     * Since this component is not deployed in `sst dev`, there is no real URL. But if you are
+     * using this component's `url` or linking to this component's `url`, it can be useful to
+     * have a placeholder URL. It avoids having to handle it being `undefined`.
+     * @default `"http://url-unavailable-in-dev.mode"`
+     */
+    url?: Input<string>;
+    /**
+     * The command that `sst dev` runs to start this in dev mode.
+     * @default `"npm run dev"`
+     */
+    command?: Input<string>;
+    /**
+     * Configure if you want to automatically start this when `sst dev` starts. You can still
+     * start it manually later.
+     * @default `true`
+     */
+    autostart?: Input<boolean>;
+    /**
+     * Change the directory from where the `command` is run.
+     * @default Uses the `path`
+     */
+    directory?: Input<string>;
+    /**
+     * The title of the tab in the multiplexer.
+     */
+    title?: Input<string>;
+}
+export interface BaseSiteFileOptions {
+    /**
+     * A glob pattern or array of glob patterns of files to apply these options to.
+     */
+    files: string | string[];
+    /**
+     * A glob pattern or array of glob patterns of files to exclude from the ones matched
+     * by the `files` glob pattern.
+     */
+    ignore?: string | string[];
+    /**
+     * The `Cache-Control` header to apply to the matched files.
+     */
+    cacheControl?: string;
+    /**
+     * The `Content-Type` header to apply to the matched files.
+     */
+    contentType?: string;
+}
+export declare function getContentType(filename: string, textEncoding: string): string;
+//# sourceMappingURL=base-site.d.ts.map

package/platform/types/components/base/base-site.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-site.d.ts","sourceRoot":"","sources":["../../../../src/components/base/base-site.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAEjC,MAAM,WAAW,WAAW;IAC1B;;;;;;;OAOG;IACH,GAAG,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACpB;;;OAGG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB;;;;OAIG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IAC3B;;;OAGG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1B;;OAEG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC;;OAEG;IACH,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC3B;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,UA6CpE"}

package/platform/types/components/base/base-ssr-site.d.ts

@@ -0,0 +1,13 @@
+import { Resource } from "@pulumi/pulumi";
+import { Prettify } from "../component";
+import { Input } from "../input";
+import { BaseSiteDev } from "./base-site";
+export interface BaseSsrSiteArgs {
+    dev?: false | Prettify<BaseSiteDev>;
+    buildCommand?: Input<string>;
+    environment?: Input<Record<string, Input<string>>>;
+    link?: Input<any[]>;
+    path?: string;
+}
+export declare function buildApp(parent: Resource, name: string, args: BaseSsrSiteArgs, sitePath: Input<string>, buildCommand?: Input<string>, buildEnvironment?: Input<Record<string, Input<string>>>): import("@pulumi/pulumi").Output<string>;
+//# sourceMappingURL=base-ssr-site.d.ts.map

package/platform/types/components/base/base-ssr-site.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-ssr-site.d.ts","sourceRoot":"","sources":["../../../../src/components/base/base-ssr-site.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAe,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAGjC,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1C,MAAM,WAAW,eAAe;IAC9B,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC;IACpC,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC7B,WAAW,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACnD,IAAI,CAAC,EAAE,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,QAAQ,CACtB,MAAM,EAAE,QAAQ,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,EACvB,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,EAC5B,gBAAgB,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,2CA+FxD"}

package/platform/types/components/base/base-static-site.d.ts

@@ -0,0 +1,199 @@
+import { Resource } from "@pulumi/pulumi";
+import { Input } from "../input.js";
+import { Prettify } from "../component.js";
+import { BaseSiteFileOptions } from "./base-site.js";
+export type BaseStaticSiteAssets = {
+    /**
+     * Character encoding for text based assets uploaded, like HTML, CSS, JS. This is
+     * used to set the `Content-Type` header when these files are served out.
+     *
+     * If set to `"none"`, then no charset will be returned in header.
+     * @default `"utf-8"`
+     * @example
+     * ```js
+     * {
+     *   assets: {
+     *     textEncoding: "iso-8859-1"
+     *   }
+     * }
+     * ```
+     */
+    textEncoding?: Input<"utf-8" | "iso-8859-1" | "windows-1252" | "ascii" | "none">;
+    /**
+     * Specify the `Content-Type` and `Cache-Control` headers for specific files. This allows
+     * you to override the default behavior for specific files using glob patterns.
+     *
+     * By default, this is set to cache CSS/JS files for 1 year and not cache HTML files.
+     *
+     * ```js
+     * {
+     *   assets: {
+     *     fileOptions: [
+     *       {
+     *         files: ["**\/*.css", "**\/*.js"],
+     *         cacheControl: "max-age=31536000,public,immutable"
+     *       },
+     *       {
+     *         files: "**\/*.html",
+     *         cacheControl: "max-age=0,no-cache,no-store,must-revalidate"
+     *       }
+     *     ]
+     *   }
+     * }
+     * ```
+     *
+     * @default `Object[]`
+     * @example
+     * You can change the default options. For example, apply `Cache-Control` and `Content-Type` to all zip files.
+     * ```js
+     * {
+     *   assets: {
+     *     fileOptions: [
+     *       {
+     *         files: "**\/*.zip",
+     *         contentType: "application/zip",
+     *         cacheControl: "private,no-cache,no-store,must-revalidate"
+     *       },
+     *     ],
+     *   }
+     * }
+     * ```
+     * Apply `Cache-Control` to all CSS and JS files except for CSS files with `index-`
+     * prefix in the `main/` directory.
+     * ```js
+     * {
+     *   assets: {
+     *     fileOptions: [
+     *       {
+     *         files: ["**\/*.css", "**\/*.js"],
+     *         ignore: "main\/index-*.css",
+     *         cacheControl: "private,no-cache,no-store,must-revalidate"
+     *       },
+     *     ],
+     *   }
+     * }
+     * ```
+     */
+    fileOptions?: Input<Prettify<BaseSiteFileOptions>[]>;
+};
+export interface BaseStaticSiteArgs {
+    path?: Input<string>;
+    /**
+     * The name of the index page of the site. This is a path relative to the root of your site, or the `path`.
+     *
+     * :::note
+     * The index page only applies to the root of your site.
+     * :::
+     *
+     * By default this is set to `index.html`. So if a visitor goes to your site, let's say `example.com`, `example.com/index.html` will be served.
+     *
+     * @default `"index.html"`
+     * @example
+     * ```js
+     * {
+     *   indexPage: "home.html"
+     * }
+     * ```
+     */
+    indexPage?: string;
+    /**
+     * The error page to display on a 403 or 404 error. This is a path relative to the root of your site, or the `path`.
+     * @default The `indexPage` of your site.
+     * @example
+     * ```js
+     * {
+     *   errorPage: "404.html"
+     * }
+     * ```
+     */
+    errorPage?: Input<string>;
+    /**
+     * Set environment variables for your static site. These are made available:
+     *
+     * 1. Locally while running your site through `sst dev`.
+     * 2. In the build process when running `build.command`.
+     *
+     * @example
+     * ```js
+     * environment: {
+     *   API_URL: api.url
+     *   STRIPE_PUBLISHABLE_KEY: "pk_test_123"
+     * }
+     * ```
+     *
+     * Some static site generators like Vite have their [concept of environment variables](https://vitejs.dev/guide/env-and-mode), and you can use this option to set them.
+     *
+     * :::note
+     * The types for the Vite environment variables are generated automatically. You can change their location through `vite.types`.
+     * :::
+     *
+     * These can be accessed as `import.meta.env` in your site. And only the ones prefixed with `VITE_` can be accessed in the browser.
+     *
+     * ```js
+     * environment: {
+     *   API_URL: api.url
+     *   // Accessible in the browser
+     *   VITE_STRIPE_PUBLISHABLE_KEY: "pk_test_123"
+     * }
+     * ```
+     */
+    environment?: Input<Record<string, Input<string>>>;
+    build?: Input<{
+        /**
+         * The command that builds the static site. It's run before your site is deployed. This is run at the root of your site, `path`.
+         * @example
+         * ```js
+         * {
+         *   build: {
+         *     command: "yarn build"
+         *   }
+         * }
+         * ```
+         */
+        command: Input<string>;
+        /**
+         * The directory where the build output of your static site is generated. This will be uploaded.
+         *
+         * The path is relative to the root of your site, `path`.
+         * @example
+         * ```js
+         * {
+         *   build: {
+         *     output: "build"
+         *   }
+         * }
+         * ```
+         */
+        output: Input<string>;
+    }>;
+    /**
+     * Configure [Vite](https://vitejs.dev) related options.
+     *
+     * :::tip
+     * If a `vite.config.ts` or `vite.config.js` file is detected in the `path`, then these options will be used during the build and deploy process.
+     * :::
+     */
+    vite?: Input<{
+        /**
+         * The path where the type definition for the `environment` variables are generated. This is relative to the `path`. [Read more](https://vitejs.dev/guide/env-and-mode#intellisense-for-typescript).
+         *
+         * @default `"src/sst-env.d.ts"`
+         * @example
+         * ```js
+         * {
+         *   vite: {
+         *     types: "other/path/sst-env.d.ts"
+         *   }
+         * }
+         * ```
+         */
+        types?: string;
+    }>;
+}
+export declare function prepare(args: BaseStaticSiteArgs): {
+    sitePath: import("@pulumi/pulumi").Output<string>;
+    environment: import("@pulumi/pulumi").Output<import("@pulumi/pulumi").UnwrappedObject<Record<string, Input<string>>>>;
+    indexPage: import("@pulumi/pulumi").Output<string>;
+};
+export declare function buildApp(parent: Resource, name: string, build: BaseStaticSiteArgs["build"], sitePath: ReturnType<typeof prepare>["sitePath"], environment: ReturnType<typeof prepare>["environment"]): import("@pulumi/pulumi").Output<string>;
+//# sourceMappingURL=base-static-site.d.ts.map

package/platform/types/components/base/base-static-site.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-static-site.d.ts","sourceRoot":"","sources":["../../../../src/components/base/base-static-site.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAEvD,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAGrD,MAAM,MAAM,oBAAoB,GAAG;IACjC;;;;;;;;;;;;;;OAcG;IACH,YAAY,CAAC,EAAE,KAAK,CAClB,OAAO,GAAG,YAAY,GAAG,cAAc,GAAG,OAAO,GAAG,MAAM,CAC3D,CAAC;IACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsDG;IACH,WAAW,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,CAAC,CAAC;CACtD,CAAC;AAEF,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrB;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;;;OASG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,WAAW,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IACnD,KAAK,CAAC,EAAE,KAAK,CAAC;QACZ;;;;;;;;;;WAUG;QACH,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QACvB;;;;;;;;;;;;WAYG;QACH,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;KACvB,CAAC,CAAC;IACH;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,KAAK,CAAC;QACX;;;;;;;;;;;;WAYG;QACH,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC,CAAC;CACJ;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,kBAAkB;;;;EAyE/C;AAED,wBAAgB,QAAQ,CACtB,MAAM,EAAE,QAAQ,EAChB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,EAClC,QAAQ,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC,UAAU,CAAC,EAChD,WAAW,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC,aAAa,CAAC,2CAgCvD"}

package/platform/types/components/cloudflare/account-id.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_ACCOUNT_ID: string;
+//# sourceMappingURL=account-id.d.ts.map

package/platform/types/components/cloudflare/account-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account-id.d.ts","sourceRoot":"","sources":["../../../../src/components/cloudflare/account-id.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,QAA6C,CAAC"}