monorise 0.0.1

package/dist/sst/.sst/platform/src/components/aws/tan-stack-start.d.ts

@@ -0,0 +1,354 @@
+import { ComponentResourceOptions, Output } from "@pulumi/pulumi";
+import { Plan, SsrSite, SsrSiteArgs } from "./ssr-site.js";
+import { RouterRouteArgs } from "./router.js";
+import { Prettify } from "../component.js";
+export interface TanStackStartArgs extends SsrSiteArgs {
+    /**
+     * Configure how this component works in `sst dev`.
+     *
+     * Instead of deploying your TanStack Start app, this starts it in dev mode. It's run
+     * as a separate process in the `sst dev` multiplexer. Read more about
+     * [`sst dev`](/docs/reference/cli/#dev).
+     *
+     * To disable dev mode, pass in `false`.
+     */
+    dev?: SsrSiteArgs["dev"];
+    /**
+     * Permissions and the resources that the [server function](#nodes-server) in your TanStack Start app needs to access. These permissions are used to create the function's IAM role.
+     *
+     * :::tip
+     * If you `link` the function to a resource, the permissions to access it are
+     * automatically added.
+     * :::
+     *
+     * @example
+     * Allow reading and writing to an S3 bucket called `my-bucket`.
+     * ```js
+     * {
+     *   permissions: [
+     *     {
+     *       actions: ["s3:GetObject", "s3:PutObject"],
+     *       resources: ["arn:aws:s3:::my-bucket/*"]
+     *     },
+     *   ]
+     * }
+     * ```
+     *
+     * Perform all actions on an S3 bucket called `my-bucket`.
+     *
+     * ```js
+     * {
+     *   permissions: [
+     *     {
+     *       actions: ["s3:*"],
+     *       resources: ["arn:aws:s3:::my-bucket/*"]
+     *     },
+     *   ]
+     * }
+     * ```
+     *
+     * Grant permissions to access all resources.
+     *
+     * ```js
+     * {
+     *   permissions: [
+     *     {
+     *       actions: ["*"],
+     *       resources: ["*"]
+     *     },
+     *   ]
+     * }
+     * ```
+     */
+    permissions?: SsrSiteArgs["permissions"];
+    /**
+     * Path to the directory where your TanStack Start app is located.  This path is relative to your `sst.config.ts`.
+     *
+     * By default it assumes your TanStack Start app is in the root of your SST app.
+     * @default `"."`
+     *
+     * @example
+     *
+     * If your TanStack Start app is in a package in your monorepo.
+     *
+     * ```js
+     * {
+     *   path: "packages/web"
+     * }
+     * ```
+     */
+    path?: SsrSiteArgs["path"];
+    /**
+     * [Link resources](/docs/linking/) to your TanStack Start app. This will:
+     *
+     * 1. Grant the permissions needed to access the resources.
+     * 2. Allow you to access it in your site using the [SDK](/docs/reference/sdk/).
+     *
+     * @example
+     *
+     * Takes a list of resources to link to the function.
+     *
+     * ```js
+     * {
+     *   link: [bucket, stripeKey]
+     * }
+     * ```
+     */
+    link?: SsrSiteArgs["link"];
+    /**
+     * Configure how the CloudFront cache invalidations are handled. This is run after your TanStack Start app has been deployed.
+     * :::tip
+     * You get 1000 free invalidations per month. After that you pay $0.005 per invalidation path. [Read more here](https://aws.amazon.com/cloudfront/pricing/).
+     * :::
+     * @default `{paths: "all", wait: false}`
+     * @example
+     * Wait for all paths to be invalidated.
+     * ```js
+     * {
+     *   invalidation: {
+     *     paths: "all",
+     *     wait: true
+     *   }
+     * }
+     * ```
+     */
+    invalidation?: SsrSiteArgs["invalidation"];
+    /**
+     * Set in your TanStack Start app. These are made available:
+     *
+     * 1. In `vinxi build`, they are loaded into `process.env`.
+     * 2. Locally while running `sst dev vinxi dev`.
+     *
+     * :::tip
+     * You can also `link` resources to your TanStack Start app and access them in a type-safe way with the [SDK](/docs/reference/sdk/). We recommend linking since it's more secure.
+     * :::
+     *
+     * @example
+     * ```js
+     * {
+     *   environment: {
+     *     API_URL: api.url,
+     *     STRIPE_PUBLISHABLE_KEY: "pk_test_123"
+     *   }
+     * }
+     * ```
+     */
+    environment?: SsrSiteArgs["environment"];
+    /**
+     * Set a custom domain for your TanStack Start app.
+     *
+     * Automatically manages domains hosted on AWS Route 53, Cloudflare, and Vercel. For other
+     * providers, you'll need to pass in a `cert` that validates domain ownership and add the
+     * DNS records.
+     *
+     * :::tip
+     * Built-in support for AWS Route 53, Cloudflare, and Vercel. And manual setup for other
+     * providers.
+     * :::
+     *
+     * @example
+     *
+     * By default this assumes the domain is hosted on Route 53.
+     *
+     * ```js
+     * {
+     *   domain: "example.com"
+     * }
+     * ```
+     *
+     * For domains hosted on Cloudflare.
+     *
+     * ```js
+     * {
+     *   domain: {
+     *     name: "example.com",
+     *     dns: sst.cloudflare.dns()
+     *   }
+     * }
+     * ```
+     *
+     * Specify a `www.` version of the custom domain.
+     *
+     * ```js
+     * {
+     *   domain: {
+     *     name: "domain.com",
+     *     redirects: ["www.domain.com"]
+     *   }
+     * }
+     * ```
+     */
+    domain?: SsrSiteArgs["domain"];
+    /**
+     * Serve your TanStack Start app through a `Router` instead of a standalone CloudFront
+     * distribution.
+     *
+     * By default, this component creates a new CloudFront distribution. But you might
+     * want to serve it through the distribution of your `Router`.
+     *
+     * :::note
+     * TanStack Start does not currently support base paths and can only be routed
+     * from the root `/` path.
+     * :::
+     *
+     * To serve your TanStack Start app **from a subdomain**, you'll need to
+     * configure the domain in your `Router` component to match both the root and the
+     * subdomain.
+     *
+     * ```ts title="sst.config.ts" {3,4}
+     * const router = new sst.aws.Router("Router", {
+     *   domain: {
+     *     name: "example.com",
+     *     aliases: ["*.example.com"]
+     *   }
+     * });
+     * ```
+     *
+     * Now set the `domain` in the `router` prop.
+     *
+     * ```ts {4}
+     * {
+     *   router: {
+     *     instance: router,
+     *     domain: "docs.example.com"
+     *   }
+     * }
+     * ```
+     */
+    router?: Prettify<Omit<RouterRouteArgs, "path">>;
+    /**
+     * The command used internally to build your TanStack Start app.
+     *
+     * @default `"npm run build"`
+     *
+     * @example
+     *
+     * If you want to use a different build command.
+     * ```js
+     * {
+     *   buildCommand: "yarn build"
+     * }
+     * ```
+     */
+    buildCommand?: SsrSiteArgs["buildCommand"];
+    /**
+     * Configure how the TanStack Start app assets are uploaded to S3.
+     *
+     * By default, this is set to the following. Read more about these options below.
+     * ```js
+     * {
+     *   assets: {
+     *     textEncoding: "utf-8",
+     *     versionedFilesCacheHeader: "public,max-age=31536000,immutable",
+     *     nonVersionedFilesCacheHeader: "public,max-age=0,s-maxage=86400,stale-while-revalidate=8640"
+     *   }
+     * }
+     * ```
+     */
+    assets?: SsrSiteArgs["assets"];
+    /**
+     * Configure the TanStack Start app to use an existing CloudFront cache policy.
+     *
+     * :::note
+     * CloudFront has a limit of 20 cache policies per account, though you can request a limit
+     * increase.
+     * :::
+     *
+     * By default, a new cache policy is created for it. This allows you to reuse an existing
+     * policy instead of creating a new one.
+     *
+     * @default A new cache policy is created
+     * @example
+     * ```js
+     * {
+     *   cachePolicy: "658327ea-f89d-4fab-a63d-7e88639e58f6"
+     * }
+     * ```
+     */
+    cachePolicy?: SsrSiteArgs["cachePolicy"];
+}
+/**
+ * The `TanStackStart` component lets you deploy a [TanStack Start](https://tanstack.com/start/latest) app to AWS.
+ *
+ * :::note
+ * You need to make sure the `vite.config.ts` file is configured to use Nitro for deployments on aws-lambda by adding the `nitro` property and setting the `preset` to `aws-lambda`.
+ * :::
+ *
+ * @example
+ *
+ * #### Minimal example
+ *
+ * Deploy a TanStack Start app that's in the project root.
+ *
+ * ```js title="sst.config.ts"
+ * new sst.aws.TanStackStart("MyWeb");
+ * ```
+ *
+ * #### Change the path
+ *
+ * Deploys the TanStack Start app in the `my-app/` directory.
+ *
+ * ```js {2} title="sst.config.ts"
+ * new sst.aws.TanStackStart("MyWeb", {
+ *   path: "my-app/"
+ * });
+ * ```
+ *
+ * #### Add a custom domain
+ *
+ * Set a custom domain for your TanStack Start app.
+ *
+ * ```js {2} title="sst.config.ts"
+ * new sst.aws.TanStackStart("MyWeb", {
+ *   domain: "my-app.com"
+ * });
+ * ```
+ *
+ * #### Redirect www to apex domain
+ *
+ * Redirect `www.my-app.com` to `my-app.com`.
+ *
+ * ```js {4} title="sst.config.ts"
+ * new sst.aws.TanStackStart("MyWeb", {
+ *   domain: {
+ *     name: "my-app.com",
+ *     redirects: ["www.my-app.com"]
+ *   }
+ * });
+ * ```
+ *
+ * #### Link resources
+ *
+ * [Link resources](/docs/linking/) to your TanStack Start app. This will grant permissions
+ * to the resources and allow you to access it in your app.
+ *
+ * ```ts {4} title="sst.config.ts"
+ * const bucket = new sst.aws.Bucket("MyBucket");
+ *
+ * new sst.aws.TanStackStart("MyWeb", {
+ *   link: [bucket]
+ * });
+ * ```
+ *
+ * You can use the [SDK](/docs/reference/sdk/) to access the linked resources
+ * in your TanStack Start app.
+ *
+ * ```ts title="src/app.tsx"
+ * import { Resource } from "sst";
+ *
+ * console.log(Resource.MyBucket.name);
+ * ```
+ */
+export declare class TanStackStart extends SsrSite {
+    constructor(name: string, args?: TanStackStartArgs, opts?: ComponentResourceOptions);
+    protected normalizeBuildCommand(): void;
+    protected buildPlan(outputPath: Output<string>): Output<Plan>;
+    /**
+     * The URL of the TanStack Start app.
+     *
+     * If the `domain` is set, this is the URL with the custom domain.
+     * Otherwise, it's the auto-generated CloudFront URL.
+     */
+    get url(): Output<string>;
+}
+//# sourceMappingURL=tan-stack-start.d.ts.map

package/dist/sst/.sst/platform/src/components/aws/tan-stack-start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tan-stack-start.d.ts","sourceRoot":"","sources":["../../../../../../.sst/platform/src/components/aws/tan-stack-start.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,wBAAwB,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAElE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAE3C,MAAM,WAAW,iBAAkB,SAAQ,WAAW;IACpD;;;;;;;;OAQG;IACH,GAAG,CAAC,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC;IACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8CG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC,aAAa,CAAC,CAAC;IACzC;;;;;;;;;;;;;;;OAeG;IACH,IAAI,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC3B;;;;;;;;;;;;;;;OAeG;IACH,IAAI,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC3B;;;;;;;;;;;;;;;;OAgBG;IACH,YAAY,CAAC,EAAE,WAAW,CAAC,cAAc,CAAC,CAAC;IAC3C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC,aAAa,CAAC,CAAC;IACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,MAAM,CAAC,EAAE,QAAQ,CAAC,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC,CAAC;IACjD;;;;;;;;;;;;;OAaG;IACH,YAAY,CAAC,EAAE,WAAW,CAAC,cAAc,CAAC,CAAC;IAC3C;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC/B;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC,aAAa,CAAC,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,qBAAa,aAAc,SAAQ,OAAO;gBAEtC,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,iBAAsB,EAC5B,IAAI,GAAE,wBAA6B;IAKrC,SAAS,CAAC,qBAAqB;IAE/B,SAAS,CAAC,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC;IA4D7D;;;;;OAKG;IACH,IAAW,GAAG,mBAEb;CACF"}

package/dist/sst/.sst/platform/src/components/aws/task.d.ts

@@ -0,0 +1,322 @@
+import { ComponentResourceOptions, Output } from "@pulumi/pulumi";
+import { Component, Prettify } from "../component.js";
+import { Link } from "../link.js";
+import { FargateBaseArgs, FargateContainerArgs } from "./fargate.js";
+import { Input } from "../input.js";
+export interface TaskArgs extends FargateBaseArgs {
+    /**
+     * The containers to run in the task.
+     *
+     * :::tip
+     * You can optionally run multiple containers in a task.
+     * :::
+     *
+     * By default this starts a single container. To add multiple containers in the task, pass
+     * in an array of containers args.
+     *
+     * ```ts
+     * {
+     *   containers: [
+     *     {
+     *       name: "app",
+     *       image: "nginxdemos/hello:plain-text"
+     *     },
+     *     {
+     *       name: "admin",
+     *       image: {
+     *         context: "./admin",
+     *         dockerfile: "Dockerfile"
+     *       }
+     *     }
+     *   ]
+     * }
+     * ```
+     *
+     * If you specify `containers`, you cannot list the above args at the top-level. For example,
+     * you **cannot** pass in `image` at the top level.
+     *
+     * ```diff lang="ts"
+     * {
+     * -  image: "nginxdemos/hello:plain-text",
+     *   containers: [
+     *     {
+     *       name: "app",
+     *       image: "nginxdemos/hello:plain-text"
+     *     },
+     *     {
+     *       name: "admin",
+     *       image: "nginxdemos/hello:plain-text"
+     *     }
+     *   ]
+     * }
+     * ```
+     *
+     * You will need to pass in `image` as a part of the `containers`.
+     */
+    containers?: Input<Prettify<FargateContainerArgs>>[];
+    /**
+     * Assign a public IP address to the task.
+     *
+     * Defaults:
+     * - If an SST VPC component is passed to the `vpc` property, tasks run in public subnets
+     * by default and `publicIp` defaults to `true`.
+     * - If a non-SST VPC is used, tasks run in the specified subnets and `publicIp` defaults
+     * to `false`.
+     *
+     * @example
+     * ```ts
+     * {
+     *   publicIp: true
+     * }
+     * ```
+     */
+    publicIp?: Input<boolean>;
+    /**
+     * Configure how this component works in `sst dev`.
+     *
+     * :::note
+     * In `sst dev` a _stub_ version of your task is deployed.
+     * :::
+     *
+     * By default, your task in not deployed in `sst dev`. Instead, you can set the `dev.command`
+     * and it'll run locally in a **Tasks** tab in the `sst dev` multiplexer.
+     *
+     * Here's what happens when you run `sst dev`:
+     *
+     * 1. A _stub_ version of your task is deployed. This is a minimal image that starts up
+     *    faster.
+     * 2. When your task is started through the SDK, the stub version is provisioned. This can
+     *    take roughly **10 - 20 seconds**.
+     * 3. The stub version proxies the payload to your local machine using the same events
+     *    system used by [Live](/docs/live/).
+     * 4. The `dev.command` is called to run your task locally. Once complete, the stub version
+     *    of your task is stopped as well.
+     *
+     * The advantage with this approach is that you can test your task locally even it's invoked
+     * remotely, or through a cron job.
+     *
+     * :::note
+     * You are charged for the time it takes to run the stub version of your task.
+     * :::
+     *
+     * Since the stub version runs while your task is running, you are charged for the time it
+     * takes to run. This is roughly **$0.02 per hour**.
+     *
+     * To disable this and deploy your task in `sst dev`, pass in `false`. Read more about
+     * [Live](/docs/live/) and [`sst dev`](/docs/reference/cli/#dev).
+     */
+    dev?: false | {
+        /**
+         * The command that `sst dev` runs in dev mode.
+         */
+        command?: Input<string>;
+        /**
+         * Change the directory from where the `command` is run.
+         * @default Uses the `image.dockerfile` path
+         */
+        directory?: Input<string>;
+    };
+}
+/**
+ * The `Task` component lets you create containers that are used for long running asynchronous
+ * work, like data processing. It uses [Amazon ECS](https://aws.amazon.com/ecs/) on
+ * [AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/AWS_Fargate.html).
+ *
+ * @example
+ *
+ * #### Create a Task
+ *
+ * Tasks are run inside an ECS Cluster. If you haven't already, create one.
+ *
+ * ```ts title="sst.config.ts"
+ * const vpc = new sst.aws.Vpc("MyVpc");
+ * const cluster = new sst.aws.Cluster("MyCluster", { vpc });
+ * ```
+ *
+ * Add the task to it.
+ *
+ * ```ts title="sst.config.ts"
+ * const task = new sst.aws.Task("MyTask", { cluster });
+ * ```
+ *
+ * #### Configure the container image
+ *
+ * By default, the task will look for a Dockerfile in the root directory. Optionally,
+ * configure the image context and dockerfile.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.Task("MyTask", {
+ *   cluster,
+ *   image: {
+ *     context: "./app",
+ *     dockerfile: "Dockerfile"
+ *   }
+ * });
+ * ```
+ *
+ * To add multiple containers in the task, pass in an array of containers args.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.Task("MyTask", {
+ *   cluster,
+ *   containers: [
+ *     {
+ *       name: "app",
+ *       image: "nginxdemos/hello:plain-text"
+ *     },
+ *     {
+ *       name: "admin",
+ *       image: {
+ *         context: "./admin",
+ *         dockerfile: "Dockerfile"
+ *       }
+ *     }
+ *   ]
+ * });
+ * ```
+ *
+ * This is useful for running sidecar containers.
+ *
+ * #### Link resources
+ *
+ * [Link resources](/docs/linking/) to your task. This will grant permissions
+ * to the resources and allow you to access it in your app.
+ *
+ * ```ts {5} title="sst.config.ts"
+ * const bucket = new sst.aws.Bucket("MyBucket");
+ *
+ * new sst.aws.Task("MyTask", {
+ *   cluster,
+ *   link: [bucket]
+ * });
+ * ```
+ *
+ * You can use the [SDK](/docs/reference/sdk/) to access the linked resources in your task.
+ *
+ * ```ts title="app.ts"
+ * import { Resource } from "sst";
+ *
+ * console.log(Resource.MyBucket.name);
+ * ```
+ *
+ * #### Task SDK
+ *
+ * With the [Task JS SDK](/docs/component/aws/task#sdk), you can run your tasks, stop your
+ * tasks, and get the status of your tasks.
+ *
+ * For example, you can link the task to a function in your app.
+ *
+ * ```ts title="sst.config.ts" {3}
+ * new sst.aws.Function("MyFunction", {
+ *   handler: "src/lambda.handler",
+ *   link: [task]
+ * });
+ * ```
+ *
+ * Then from your function run the task.
+ *
+ * ```ts title="src/lambda.ts"
+ * import { Resource } from "sst";
+ * import { task } from "sst/aws/task";
+ *
+ * const runRet = await task.run(Resource.MyTask);
+ * const taskArn = runRet.arn;
+ * ```
+ *
+ * If you are not using Node.js, you can use the AWS SDK instead. Here's
+ * [how to run a task](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html).
+ *
+ * ---
+ *
+ * ### Cost
+ *
+ * By default, this uses a _Linux/X86_ _Fargate_ container with 0.25 vCPUs at $0.04048 per
+ * vCPU per hour and 0.5 GB of memory at $0.004445 per GB per hour. It includes 20GB of
+ * _Ephemeral Storage_ for free with additional storage at $0.000111 per GB per hour. Each
+ * container also gets a public IPv4 address at $0.005 per hour.
+ *
+ * It works out to $0.04048 x 0.25 + $0.004445 x 0.5 + $0.005. Or **$0.02 per hour**
+ * your task runs for.
+ *
+ * Adjust this for the `cpu`, `memory` and `storage` you are using. And
+ * check the prices for _Linux/ARM_ if you are using `arm64` as your `architecture`.
+ *
+ * The above are rough estimates for _us-east-1_, check out the
+ * [Fargate pricing](https://aws.amazon.com/fargate/pricing/) and the
+ * [Public IPv4 Address pricing](https://aws.amazon.com/vpc/pricing/) for more details.
+ */
+export declare class Task extends Component implements Link.Linkable {
+    private readonly _cluster;
+    private readonly vpc;
+    private readonly executionRole;
+    private readonly taskRole;
+    private readonly _taskDefinition;
+    private readonly _publicIp;
+    private readonly containerNames;
+    private readonly dev;
+    constructor(name: string, args: TaskArgs, opts?: ComponentResourceOptions);
+    /**
+     * The ARN of the ECS Task Definition.
+     */
+    get taskDefinition(): Output<string>;
+    /**
+     * The names of the containers in the task.
+     * @internal
+     */
+    get containers(): Output<Output<string>[]>;
+    /**
+     * The ARN of the cluster this task is deployed to.
+     * @internal
+     */
+    get cluster(): Output<string>;
+    /**
+     * The security groups for the task.
+     * @internal
+     */
+    get securityGroups(): Output<Output<string>[]>;
+    /**
+     * The subnets for the task.
+     * @internal
+     */
+    get subnets(): Output<Output<string>[]>;
+    /**
+     * Whether to assign a public IP address to the task.
+     * @internal
+     */
+    get assignPublicIp(): $util.OutputInstance<boolean>;
+    /**
+     * The underlying [resources](/docs/components/#nodes) this component creates.
+     */
+    get nodes(): {
+        /**
+         * The Amazon ECS Execution Role.
+         */
+        executionRole: import("@pulumi/aws/iam/role.js").Role;
+        /**
+         * The Amazon ECS Task Role.
+         */
+        taskRole: import("@pulumi/aws/iam/role.js").Role;
+        /**
+         * The Amazon ECS Task Definition.
+         */
+        taskDefinition: Output<import("@pulumi/aws/ecs/taskDefinition.js").TaskDefinition>;
+    };
+    /** @internal */
+    getSSTLink(): {
+        properties: {
+            cluster: Output<string>;
+            containers: Output<Output<string>[]>;
+            taskDefinition: Output<string>;
+            subnets: Output<Output<string>[]>;
+            securityGroups: Output<Output<string>[]>;
+            assignPublicIp: $util.OutputInstance<boolean>;
+        };
+        include: {
+            effect?: "allow" | "deny" | undefined;
+            actions: string[];
+            resources: Input<Input<string>[]>;
+            type: "aws.permission";
+        }[];
+    };
+}
+//# sourceMappingURL=task.d.ts.map

package/dist/sst/.sst/platform/src/components/aws/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../../../../../.sst/platform/src/components/aws/task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,wBAAwB,EAAE,MAAM,EAAU,MAAM,gBAAgB,CAAC;AAC/E,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAMlC,OAAO,EACL,eAAe,EACf,oBAAoB,EASrB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,MAAM,WAAW,QAAS,SAAQ,eAAe;IAC/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;IACH,UAAU,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAAC,EAAE,CAAC;IACrD;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,GAAG,CAAC,EACA,KAAK,GACL;QACE;;WAEG;QACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QACxB;;;WAGG;QACH,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;KAC3B,CAAC;CACP;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+HG;AACH,qBAAa,IAAK,SAAQ,SAAU,YAAW,IAAI,CAAC,QAAQ;IAC1D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;IACnC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAIlB;IACF,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAW;IACzC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;IACpC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA6B;IAC7D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkB;IAC5C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA2B;IAC1D,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAU;gBAG5B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,QAAQ,EACd,IAAI,GAAE,wBAA6B;IA0HrC;;OAEG;IACH,IAAW,cAAc,mBAExB;IAED;;;OAGG;IACH,IAAW,UAAU,6BAEpB;IAED;;;OAGG;IACH,IAAW,OAAO,mBAEjB;IAED;;;OAGG;IACH,IAAW,cAAc,6BAExB;IAED;;;OAGG;IACH,IAAW,OAAO,6BAEjB;IAED;;;OAGG;IACH,IAAW,cAAc,kCAExB;IAED;;OAEG;IACH,IAAW,KAAK;QAEZ;;WAEG;;QAEH;;WAEG;;QAEH;;WAEG;;MAGN;IAED,gBAAgB;IACT,UAAU;;;;;;;;;;;;;;;;CA4BlB"}