@sst-community/sst 4.19.0 → 5.0.0-alpha.1

package/platform/types/components/aws/v5/cognito-user-pool.d.ts

@@ -0,0 +1,396 @@
+import { ComponentResourceOptions, Output } from "@pulumi/pulumi";
+import { V5Args } from "../../parts-component";
+import type { Plain } from "../../args";
+import type { Input } from "../../input";
+import { DnsValidatedCertificate } from "../dns-validated-certificate";
+import { Function } from "./function";
+import { CustomDomainArgs } from "../helpers/custom-domain";
+import type { CognitoIdentityProviderArgs, CognitoUserPoolArgs as OriginalCognitoUserPoolArgs } from "../cognito-user-pool";
+import { CognitoUserPoolClient, CognitoUserPoolClientArgs } from "./cognito-user-pool-client";
+declare const parts: () => {
+    /**
+     * The Amazon Cognito User Pool.
+     */
+    userPool: typeof import("@pulumi/aws/cognito/userPool").UserPool;
+    /**
+     * The function behind each trigger, by trigger: `preSignUp`,
+     * `postConfirmation` and so on.
+     */
+    trigger: import("../..").ManyPart<import("../..").DeferredPart<typeof Function>>;
+    /**
+     * The permission that lets the user pool invoke each trigger's function, by
+     * trigger.
+     */
+    permission: import("../..").ManyPart<typeof import("@pulumi/aws/lambda/permission").Permission>;
+    /**
+     * The certificate for the custom domain, created when `domain` is a custom
+     * domain without a `cert`.
+     */
+    certificate: import("../..").OptionalPart<typeof DnsValidatedCertificate>;
+    /**
+     * The domain of the hosted UI, when `domain` is set.
+     */
+    domain: import("../..").OptionalPart<typeof import("@pulumi/aws/cognito/userPoolDomain").UserPoolDomain>;
+    /**
+     * The identity providers added with `addIdentityProvider`, by provider name.
+     */
+    identityProvider: import("../..").ManyPart<typeof import("@pulumi/aws/cognito/identityProvider").IdentityProvider>;
+};
+export interface CognitoUserPoolPrefixDomainArgs {
+    /**
+     * Use an Amazon Cognito prefix domain. Creates a domain at
+     * `{prefix}.auth.{region}.amazoncognito.com`.
+     *
+     * Cannot contain "aws", "amazon", or "cognito".
+     */
+    prefix: Input<string>;
+}
+export interface CognitoUserPoolDomainArgs extends CustomDomainArgs {
+    /**
+     * The custom domain name. Must be a subdomain (e.g., `auth.example.com`).
+     */
+    name: Input<string>;
+    /**
+     * ARN of an existing ACM certificate in `us-east-1`. By default, a certificate
+     * is created and validated automatically.
+     */
+    cert?: Input<string>;
+}
+export interface CognitoUserPoolArgs extends V5Args<Omit<OriginalCognitoUserPoolArgs, "domain" | "triggers">, typeof parts> {
+    /**
+     * Configure triggers for this User Pool. Each one takes the handler path,
+     * the function args, or a function ARN.
+     *
+     * The functions are in the user pool's `nodes.trigger`, by trigger, and
+     * `transform.trigger` changes them.
+     *
+     * @default No triggers
+     * @example
+     *
+     * ```js
+     * {
+     *   triggers: {
+     *     preAuthentication: "src/preAuthentication.handler",
+     *     postAuthentication: "src/postAuthentication.handler"
+     *   }
+     * }
+     * ```
+     */
+    triggers?: Plain<OriginalCognitoUserPoolArgs["triggers"]>;
+    /**
+     * Configure a domain for the User Pool's hosted UI.
+     *
+     * You can use either a Cognito-provided prefix domain or your own custom domain.
+     *
+     * @example
+     *
+     * Add a Cognito prefix domain.
+     *
+     * ```ts
+     * {
+     *   domain: {
+     *     prefix: "my-app-dev"
+     *   }
+     * }
+     * ```
+     *
+     * This creates a domain at `my-app-dev.auth.{region}.amazoncognito.com`.
+     *
+     * Add a custom domain. By default, creates an ACM certificate and configures
+     * DNS records using Route 53.
+     *
+     * ```ts
+     * {
+     *   domain: "auth.example.com"
+     * }
+     * ```
+     *
+     * Use a domain hosted on Cloudflare.
+     *
+     * ```ts
+     * {
+     *   domain: {
+     *     name: "auth.example.com",
+     *     dns: sst.cloudflare.dns()
+     *   }
+     * }
+     * ```
+     */
+    domain?: string | CognitoUserPoolPrefixDomainArgs | CognitoUserPoolDomainArgs;
+}
+export interface CognitoUserPoolAddClientArgs extends Omit<CognitoUserPoolClientArgs, "userPool"> {
+}
+export interface CognitoUserPoolIdentityProviderArgs extends Omit<CognitoIdentityProviderArgs, "transform"> {
+}
+declare const CognitoUserPool_base: import("../..").ComponentClass<{
+    /**
+     * The Amazon Cognito User Pool.
+     */
+    userPool: typeof import("@pulumi/aws/cognito/userPool").UserPool;
+    /**
+     * The function behind each trigger, by trigger: `preSignUp`,
+     * `postConfirmation` and so on.
+     */
+    trigger: import("../..").ManyPart<import("../..").DeferredPart<typeof Function>>;
+    /**
+     * The permission that lets the user pool invoke each trigger's function, by
+     * trigger.
+     */
+    permission: import("../..").ManyPart<typeof import("@pulumi/aws/lambda/permission").Permission>;
+    /**
+     * The certificate for the custom domain, created when `domain` is a custom
+     * domain without a `cert`.
+     */
+    certificate: import("../..").OptionalPart<typeof DnsValidatedCertificate>;
+    /**
+     * The domain of the hosted UI, when `domain` is set.
+     */
+    domain: import("../..").OptionalPart<typeof import("@pulumi/aws/cognito/userPoolDomain").UserPoolDomain>;
+    /**
+     * The identity providers added with `addIdentityProvider`, by provider name.
+     */
+    identityProvider: import("../..").ManyPart<typeof import("@pulumi/aws/cognito/identityProvider").IdentityProvider>;
+}>;
+/**
+ * The `CognitoUserPool` component lets you add a [Amazon Cognito User Pool](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html) to your app.
+ *
+ * It's built from parts, so every resource it creates can be transformed, is available in
+ * `nodes`, and can be swapped for one you already have. That includes its identity
+ * providers and the functions behind its triggers.
+ *
+ * @example
+ *
+ * #### Create the user pool
+ *
+ * ```ts title="sst.config.ts"
+ * const userPool = new sst.aws.v5.CognitoUserPool("MyUserPool");
+ * ```
+ *
+ * #### Login using email
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.CognitoUserPool("MyUserPool", {
+ *   usernames: ["email"]
+ * });
+ * ```
+ *
+ * #### Add a hosted UI domain
+ *
+ * Use a Cognito prefix domain for the hosted UI.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.CognitoUserPool("MyUserPool", {
+ *   domain: {
+ *     prefix: "my-app-dev"
+ *   }
+ * });
+ * ```
+ *
+ * Or use your own custom domain.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.CognitoUserPool("MyUserPool", {
+ *   domain: "auth.example.com"
+ * });
+ * ```
+ *
+ * #### Configure triggers
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.CognitoUserPool("MyUserPool", {
+ *   triggers: {
+ *     preAuthentication: "src/preAuthentication.handler",
+ *     postAuthentication: "src/postAuthentication.handler",
+ *   },
+ * });
+ * ```
+ *
+ * #### Add Google identity provider
+ *
+ * ```ts title="sst.config.ts"
+ * const GoogleClientId = new sst.Secret("GOOGLE_CLIENT_ID");
+ * const GoogleClientSecret = new sst.Secret("GOOGLE_CLIENT_SECRET");
+ *
+ * const provider = userPool.addIdentityProvider("Google", {
+ *   type: "google",
+ *   details: {
+ *     authorize_scopes: "email profile",
+ *     client_id: GoogleClientId.value,
+ *     client_secret: GoogleClientSecret.value,
+ *   },
+ *   attributes: {
+ *     email: "email",
+ *     name: "name",
+ *     username: "sub",
+ *   },
+ * });
+ * ```
+ *
+ * #### Add a client
+ *
+ * ```ts title="sst.config.ts"
+ * const client = userPool.addClient("Web", {
+ *   providers: [provider.providerName]
+ * });
+ * ```
+ *
+ * A client is a component of its own, so you can link it. Its ID and secret are then
+ * available as `Resource.Web.id` and `Resource.Web.secret`.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.Nextjs("MyWeb", {
+ *   link: [client]
+ * });
+ * ```
+ *
+ * #### Switch from `sst.aws.CognitoUserPool`
+ *
+ * Change `sst.aws.CognitoUserPool` to `sst.aws.v5.CognitoUserPool` and keep the name. The
+ * user pool, its domain, its clients, its identity providers and its trigger functions are
+ * kept. A few things are written differently:
+ *
+ * - `addIdentityProvider` returns the Cognito identity provider. `provider.providerName`
+ *   reads as before.
+ * - An identity provider's own `transform` becomes the user pool's
+ *   `transform.identityProvider`.
+ * - `domain`, `domain.dns` and `triggers` have to be plain values, not outputs.
+ * - `get` gives its options to the component, so a `provider` or `parent` you pass it
+ *   applies to what you add to the user pool too. `sst.aws.CognitoUserPool.get` gave them
+ *   to the user pool it looked up and to nothing else. If you pass `get` a `provider` and
+ *   add a client to that user pool, the client is replaced on switch, to be created with
+ *   that provider, and gets a new ID.
+ *
+ * ```ts title="sst.config.ts" del={1} ins={2}
+ * const userPool = new sst.aws.CognitoUserPool("MyUserPool");
+ * const userPool = new sst.aws.v5.CognitoUserPool("MyUserPool");
+ * ```
+ */
+export declare class CognitoUserPool extends CognitoUserPool_base {
+    private hostedUiUrl?;
+    constructor(name: string, args?: CognitoUserPoolArgs, opts?: ComponentResourceOptions);
+    private createTriggers;
+    private createDomain;
+    /**
+     * The Cognito User Pool ID.
+     */
+    get id(): Output<string>;
+    /**
+     * The Cognito User Pool ARN.
+     */
+    get arn(): Output<string>;
+    /**
+     * If a `domain` is configured, this is the full URL of the hosted UI.
+     */
+    get domainUrl(): Output<string> | undefined;
+    /**
+     * Add a client to the User Pool.
+     *
+     * @param name Name of the client.
+     * @param args Configure the client.
+     * @param opts Resource options.
+     *
+     * @example
+     *
+     * ```ts title="sst.config.ts"
+     * const client = userPool.addClient("Web");
+     * ```
+     *
+     * This returns the client as a component of its own, with its `id` and `secret`. Link it
+     * to read them at runtime as `Resource.Web.id` and `Resource.Web.secret`.
+     */
+    addClient(name: string, args?: CognitoUserPoolAddClientArgs, opts?: ComponentResourceOptions): CognitoUserPoolClient;
+    /**
+     * Add a federated identity provider to the User Pool.
+     *
+     * @param name Name of the identity provider.
+     * @param args Configure the identity provider.
+     *
+     * @example
+     *
+     * For example, add a GitHub (OIDC) identity provider.
+     *
+     * ```ts title="sst.config.ts"
+     * const GithubClientId = new sst.Secret("GITHUB_CLIENT_ID");
+     * const GithubClientSecret = new sst.Secret("GITHUB_CLIENT_SECRET");
+     *
+     * const provider = userPool.addIdentityProvider("GitHub", {
+     *   type: "oidc",
+     *   details: {
+     *      authorize_scopes: "read:user user:email",
+     *      client_id: GithubClientId.value,
+     *      client_secret: GithubClientSecret.value,
+     *      oidc_issuer: "https://github.com/",
+     *   },
+     *   attributes: {
+     *     email: "email",
+     *     username: "sub",
+     *   },
+     * });
+     * ```
+     *
+     * This returns the Cognito identity provider. Pass its `providerName` to the clients that
+     * use it, so they're created after the provider.
+     *
+     * ```ts title="sst.config.ts"
+     * userPool.addClient("Web", {
+     *   providers: [provider.providerName]
+     * });
+     * ```
+     */
+    addIdentityProvider(name: string, args: CognitoUserPoolIdentityProviderArgs): import("@pulumi/aws/cognito/identityProvider").IdentityProvider;
+    /**
+     * Linking a user pool gives the linked resource its ID, and access to the
+     * user pool.
+     */
+    link(): {
+        properties: {
+            id: Output<string>;
+        };
+        include: {
+            effect?: "allow" | "deny" | undefined;
+            actions: string[];
+            resources: Input<Input<string>[]>;
+            conditions?: Input<Input<{
+                test: Input<string>;
+                variable: Input<string>;
+                values: Input<Input<string>[]>;
+            }>[]> | undefined;
+            type: "aws.permission";
+        }[];
+    };
+    /**
+     * Reference an existing User Pool with the given ID. This is useful when you
+     * create a User Pool in one stage and want to share it in another. It avoids having to
+     * create a new User Pool in the other stage.
+     *
+     * :::tip
+     * You can use the `static get` method to share User Pools across stages.
+     * :::
+     *
+     * @param name The name of the component.
+     * @param userPoolID The ID of the existing User Pool.
+     * @param opts Resource options.
+     *
+     * @example
+     * Imagine you create a User Pool in the `dev` stage. And in your personal stage `frank`,
+     * instead of creating a new pool, you want to share the same pool from `dev`.
+     *
+     * ```ts title="sst.config.ts"
+     * const userPool = $app.stage === "frank"
+     *   ? sst.aws.v5.CognitoUserPool.get("MyUserPool", "us-east-1_gcF5PjhQK")
+     *   : new sst.aws.v5.CognitoUserPool("MyUserPool");
+     * ```
+     *
+     * Here `us-east-1_gcF5PjhQK` is the ID of the User Pool created in the `dev` stage.
+     * You can find this by outputting the User Pool ID in the `dev` stage.
+     *
+     * ```ts title="sst.config.ts"
+     * return {
+     *   userPool: userPool.id
+     * };
+     * ```
+     */
+    static get(name: string, userPoolID: Input<string>, opts?: ComponentResourceOptions): CognitoUserPool;
+}
+export {};
+//# sourceMappingURL=cognito-user-pool.d.ts.map

package/platform/types/components/aws/v5/cognito-user-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cognito-user-pool.d.ts","sourceRoot":"","sources":["../../../../../src/components/aws/v5/cognito-user-pool.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,MAAM,EAIP,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,MAAM,EAKP,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,gBAAgB,EAAgB,MAAM,0BAA0B,CAAC;AAK1E,OAAO,KAAK,EACV,2BAA2B,EAC3B,mBAAmB,IAAI,2BAA2B,EACnD,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EAC1B,MAAM,4BAA4B,CAAC;AAEpC,QAAA,MAAM,KAAK;IACT;;OAEG;;IAEH;;;OAGG;;IAEH;;;OAGG;;IAEH;;;OAGG;;IAEH;;OAEG;;IAEH;;OAEG;;CAEH,CAAC;AAIH,MAAM,WAAW,+BAA+B;IAC9C;;;;;OAKG;IACH,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACvB;AAED,MAAM,WAAW,yBAA0B,SAAQ,gBAAgB;IACjE;;OAEG;IACH,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACpB;;;OAGG;IACH,IAAI,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACtB;AAED,MAAM,WAAW,mBACf,SAAQ,MAAM,CAAC,IAAI,CAAC,2BAA2B,EAAE,QAAQ,GAAG,UAAU,CAAC,EAAE,OAAO,KAAK,CAAC;IACtF;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,EAAE,KAAK,CAAC,2BAA2B,CAAC,UAAU,CAAC,CAAC,CAAC;IAC1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,MAAM,CAAC,EACH,MAAM,GACN,+BAA+B,GAC/B,yBAAyB,CAAC;CAC/B;AAED,MAAM,WAAW,4BACf,SAAQ,IAAI,CAAC,yBAAyB,EAAE,UAAU,CAAC;CAAG;AAExD,MAAM,WAAW,mCACf,SAAQ,IAAI,CAAC,2BAA2B,EAAE,WAAW,CAAC;CAAG;;IA5HzD;;OAEG;;IAEH;;;OAGG;;IAEH;;;OAGG;;IAEH;;;OAGG;;IAEH;;OAEG;;IAEH;;OAEG;;;AAqGL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiHG;AACH,qBAAa,eAAgB,SAAQ,oBAGpC;IACC,OAAO,CAAC,WAAW,CAAC,CAAiB;gBAGnC,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,mBAAwB,EAC9B,IAAI,CAAC,EAAE,wBAAwB;IAuFjC,OAAO,CAAC,cAAc;IAkDtB,OAAO,CAAC,YAAY;IA6CpB;;OAEG;IACH,IAAW,EAAE,mBAEZ;IAED;;OAEG;IACH,IAAW,GAAG,mBAEb;IAED;;OAEG;IACH,IAAW,SAAS,+BAEnB;IAED;;;;;;;;;;;;;;;OAeG;IACI,SAAS,CACd,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,4BAAiC,EACvC,IAAI,CAAC,EAAE,wBAAwB;IASjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACI,mBAAmB,CACxB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,mCAAmC;IAmB3C;;;OAGG;IACI,IAAI;;;;;;;;;;;;;;;;IASX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;WACW,GAAG,CACf,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,EACzB,IAAI,CAAC,EAAE,wBAAwB;CAQlC"}

package/platform/types/components/aws/v5/cron-v2.d.ts

@@ -0,0 +1,206 @@
+import { ComponentResourceOptions } from "@pulumi/pulumi";
+import { V5Args } from "../../parts-component";
+import type { Input } from "../../input";
+import type { Function as OriginalFunction, FunctionArgs as OriginalFunctionArgs, FunctionArn } from "../function";
+import { Function, type FunctionArgs } from "./function";
+import type { Task as OriginalTask } from "../task";
+import type { Task } from "./task";
+import type { Workflow } from "../workflow";
+import type { CronV2Args as OriginalCronV2Args } from "../cron-v2";
+declare const parts: () => {
+    /**
+     * The function that's invoked when the cron job runs. There isn't one when the job runs
+     * a task.
+     */
+    function: import("../..").DeferredPart<typeof Function>;
+    /**
+     * The IAM role EventBridge Scheduler assumes to invoke the function or run the task.
+     */
+    role: typeof import("@pulumi/aws/iam/role").Role;
+    /**
+     * The EventBridge Scheduler schedule.
+     */
+    schedule: typeof import("@pulumi/aws/scheduler/schedule").Schedule;
+};
+export interface CronV2Args extends V5Args<Omit<OriginalCronV2Args, "job" | "function" | "task">, typeof parts> {
+    /**
+     * The function that'll be executed when the cron job runs.
+     *
+     * @example
+     *
+     * ```ts
+     * {
+     *   function: "src/cron.handler"
+     * }
+     * ```
+     *
+     * You can pass in the full function props.
+     *
+     * ```ts
+     * {
+     *   function: {
+     *     handler: "src/cron.handler",
+     *     timeout: "60 seconds"
+     *   }
+     * }
+     * ```
+     *
+     * You can also pass in a function ARN.
+     *
+     * ```ts
+     * {
+     *   function: "arn:aws:lambda:us-east-1:000000000000:function:my-sst-app-jayair-MyFunction",
+     * }
+     * ```
+     */
+    function?: Input<string | Workflow | OriginalFunction | Function | OriginalFunctionArgs | FunctionArgs | FunctionArn>;
+    /**
+     * The task that'll be executed when the cron job runs.
+     *
+     * @example
+     *
+     * For example, let's say you have a task.
+     *
+     * ```js title="sst.config.ts"
+     * const vpc = new sst.aws.Vpc("MyVpc");
+     * const cluster = new sst.aws.v5.Cluster("MyCluster", { vpc });
+     * const task = new sst.aws.v5.Task("MyTask", { cluster });
+     * ```
+     *
+     * You can then pass in the task to the cron job.
+     *
+     * ```js title="sst.config.ts"
+     * new sst.aws.v5.CronV2("MyCronJob", {
+     *   task,
+     *   schedule: "rate(1 minute)"
+     * });
+     * ```
+     */
+    task?: OriginalTask | Task;
+}
+declare const CronV2_base: import("../..").ComponentClass<{
+    /**
+     * The function that's invoked when the cron job runs. There isn't one when the job runs
+     * a task.
+     */
+    function: import("../..").DeferredPart<typeof Function>;
+    /**
+     * The IAM role EventBridge Scheduler assumes to invoke the function or run the task.
+     */
+    role: typeof import("@pulumi/aws/iam/role").Role;
+    /**
+     * The EventBridge Scheduler schedule.
+     */
+    schedule: typeof import("@pulumi/aws/scheduler/schedule").Schedule;
+}>;
+/**
+ * The `CronV2` component lets you add cron jobs to your app
+ * using [Amazon EventBridge Scheduler](https://docs.aws.amazon.com/scheduler/latest/UserGuide/what-is-scheduler.html). The cron job can invoke a function or a container `Task`.
+ *
+ * It takes the same args as [`sst.aws.CronV2`](/docs/component/aws/cron-v2) and creates
+ * the same resources. It's built from parts, so every resource it creates can be
+ * transformed, is available in `nodes`, and can be swapped for one you already have.
+ *
+ * @example
+ * #### Cron job function
+ *
+ * Pass in a `schedule` and a `function` that'll be executed.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.CronV2("MyCronJob", {
+ *   function: "src/cron.handler",
+ *   schedule: "rate(1 minute)"
+ * });
+ * ```
+ *
+ * #### Cron job container task
+ *
+ * Create a container task and pass in a `schedule` and a `task` that'll be executed.
+ *
+ * ```ts title="sst.config.ts" {6}
+ * const vpc = new sst.aws.Vpc("MyVpc");
+ * const cluster = new sst.aws.v5.Cluster("MyCluster", { vpc });
+ * const task = new sst.aws.v5.Task("MyTask", { cluster });
+ *
+ * new sst.aws.v5.CronV2("MyCronJob", {
+ *   task,
+ *   schedule: "rate(1 day)"
+ * });
+ * ```
+ *
+ * #### Set a timezone
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.CronV2("MyCronJob", {
+ *   function: "src/cron.handler",
+ *   schedule: "cron(15 10 * * ? *)",
+ *   timezone: "America/New_York"
+ * });
+ * ```
+ *
+ * #### Configure retries
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.CronV2("MyCronJob", {
+ *   function: "src/cron.handler",
+ *   schedule: "rate(1 minute)",
+ *   retries: 3
+ * });
+ * ```
+ *
+ * #### One-time schedule
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.CronV2("MyCronJob", {
+ *   function: "src/cron.handler",
+ *   schedule: "at(2025-06-01T10:00:00)"
+ * });
+ * ```
+ *
+ * #### Customize the function
+ *
+ * ```js title="sst.config.ts"
+ * new sst.aws.v5.CronV2("MyCronJob", {
+ *   schedule: "rate(1 minute)",
+ *   function: {
+ *     handler: "src/cron.handler",
+ *     timeout: "60 seconds"
+ *   }
+ * });
+ * ```
+ *
+ * #### Switch from `sst.aws.CronV2`
+ *
+ * Change `sst.aws.CronV2` to `sst.aws.v5.CronV2` and keep the name. The schedule, its role
+ * and the function you've deployed are kept.
+ *
+ * ```ts title="sst.config.ts" del={1-4} ins={5-8}
+ * new sst.aws.CronV2("MyCronJob", {
+ *   function: "src/cron.handler",
+ *   schedule: "rate(1 minute)"
+ * });
+ * new sst.aws.v5.CronV2("MyCronJob", {
+ *   function: "src/cron.handler",
+ *   schedule: "rate(1 minute)"
+ * });
+ * ```
+ *
+ * A few things are written differently:
+ *
+ * - The deprecated `job` is gone. Use `function`, which takes the same things. So is
+ *   `nodes.job`: read `nodes.function`.
+ * - The function is named after `function`: `MyCronJobFunction`, where it was
+ *   `MyCronJobHandler`. The function you've deployed keeps its name in AWS.
+ * - `nodes.function` is empty for a job that runs a task, where `sst.aws.CronV2` failed
+ *   when it was read.
+ * - The function is a [`sst.aws.v5.Function`](/docs/component/aws/v5/function), so its
+ *   definition can be written the way that takes it. The way `sst.aws.Function` takes it
+ *   still works.
+ * - If you set part of the schedule's `target` with an object in `transform`, the rest
+ *   of the target is kept.
+ */
+export declare class CronV2 extends CronV2_base {
+    constructor(name: string, args: CronV2Args, opts?: ComponentResourceOptions);
+}
+export {};
+//# sourceMappingURL=cron-v2.d.ts.map

package/platform/types/components/aws/v5/cron-v2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-v2.d.ts","sourceRoot":"","sources":["../../../../../src/components/aws/v5/cron-v2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,wBAAwB,EAAU,MAAM,gBAAgB,CAAC;AAEvE,OAAO,EAAE,MAAM,EAAuB,MAAM,uBAAuB,CAAC;AAEpE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,KAAK,EACV,QAAQ,IAAI,gBAAgB,EAC5B,YAAY,IAAI,oBAAoB,EACpC,WAAW,EACZ,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,QAAQ,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAEzD,OAAO,KAAK,EAAE,IAAI,IAAI,YAAY,EAAE,MAAM,SAAS,CAAC;AACpD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,IAAI,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEnE,QAAA,MAAM,KAAK;IACT;;;OAGG;;IAEH;;OAEG;;IAEH;;OAEG;;CAEH,CAAC;AAEH,MAAM,WAAW,UACf,SAAQ,MAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE,KAAK,GAAG,UAAU,GAAG,MAAM,CAAC,EAAE,OAAO,KAAK,CAAC;IACnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,QAAQ,CAAC,EAAE,KAAK,CACZ,MAAM,GACN,QAAQ,GACR,gBAAgB,GAChB,QAAQ,GACR,oBAAoB,GACpB,YAAY,GACZ,WAAW,CACd,CAAC;IACF;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,IAAI,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;CAC5B;;IA/EC;;;OAGG;;IAEH;;OAEG;;IAEH;;OAEG;;;AAsEL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGG;AACH,qBAAa,MAAO,SAAQ,WAAkC;gBAE1D,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,EAChB,IAAI,CAAC,EAAE,wBAAwB;CAyGlC"}