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

package/platform/types/components/aws/v5/bus.d.ts

@@ -0,0 +1,255 @@
+import { ComponentResourceOptions } from "@pulumi/pulumi";
+import { V5Args } from "../../parts-component";
+import type { Input } from "../../input";
+import { Function } from "./function";
+import { type FunctionDefinition } from "../helpers/function-part";
+import type { Queue as OriginalQueue } from "../queue";
+import type { Queue } from "./queue";
+import type { BusArgs as OriginalBusArgs, BusSubscriberArgs as OriginalBusSubscriberArgs } from "../bus";
+declare const parts: () => {
+    /**
+     * The EventBridge event bus.
+     */
+    bus: typeof import("@pulumi/aws/cloudwatch/eventBus").EventBus;
+    /**
+     * The functions subscribed to the bus, by subscriber name.
+     */
+    subscriber: import("../..").ManyPart<import("../..").DeferredPart<typeof Function>>;
+    /**
+     * The permission that lets EventBridge invoke each function subscriber, by
+     * subscriber name.
+     */
+    permission: import("../..").ManyPart<typeof import("@pulumi/aws/lambda/permission").Permission>;
+    /**
+     * The rule that matches the events of each subscriber, by subscriber name.
+     */
+    rule: import("../..").ManyPart<typeof import("@pulumi/aws/cloudwatch/eventRule").EventRule>;
+    /**
+     * The target that sends what each rule matches to its subscriber, by
+     * subscriber name.
+     */
+    target: import("../..").ManyPart<typeof import("@pulumi/aws/cloudwatch/eventTarget").EventTarget>;
+    /**
+     * The policy that lets EventBridge send to each queue subscriber, by
+     * subscriber name.
+     */
+    queuePolicy: import("../..").ManyPart<typeof import("@pulumi/aws/sqs/queuePolicy").QueuePolicy>;
+};
+export interface BusArgs extends V5Args<OriginalBusArgs, typeof parts> {
+}
+export interface BusSubscriberArgs extends Omit<OriginalBusSubscriberArgs, "transform"> {
+}
+declare const Bus_base: import("../..").ComponentClass<{
+    /**
+     * The EventBridge event bus.
+     */
+    bus: typeof import("@pulumi/aws/cloudwatch/eventBus").EventBus;
+    /**
+     * The functions subscribed to the bus, by subscriber name.
+     */
+    subscriber: import("../..").ManyPart<import("../..").DeferredPart<typeof Function>>;
+    /**
+     * The permission that lets EventBridge invoke each function subscriber, by
+     * subscriber name.
+     */
+    permission: import("../..").ManyPart<typeof import("@pulumi/aws/lambda/permission").Permission>;
+    /**
+     * The rule that matches the events of each subscriber, by subscriber name.
+     */
+    rule: import("../..").ManyPart<typeof import("@pulumi/aws/cloudwatch/eventRule").EventRule>;
+    /**
+     * The target that sends what each rule matches to its subscriber, by
+     * subscriber name.
+     */
+    target: import("../..").ManyPart<typeof import("@pulumi/aws/cloudwatch/eventTarget").EventTarget>;
+    /**
+     * The policy that lets EventBridge send to each queue subscriber, by
+     * subscriber name.
+     */
+    queuePolicy: import("../..").ManyPart<typeof import("@pulumi/aws/sqs/queuePolicy").QueuePolicy>;
+}>;
+/**
+ * The `Bus` component lets you add an [Amazon EventBridge Event Bus](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-bus.html) to your app.
+ *
+ * It takes the same args as [`sst.aws.Bus`](/docs/component/aws/bus) 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. That includes the
+ * resources of each subscriber, which are kept inside the bus.
+ *
+ * @example
+ *
+ * #### Create a bus
+ *
+ * ```ts title="sst.config.ts"
+ * const bus = new sst.aws.v5.Bus("MyBus");
+ * ```
+ *
+ * #### Add a subscriber
+ *
+ * Each subscriber has a name.
+ *
+ * ```ts title="sst.config.ts"
+ * bus.subscribe("MySubscriber", "src/subscriber.handler", {
+ *   pattern: { detailType: ["order.created"] }
+ * });
+ * ```
+ *
+ * #### Subscribe to a bus that isn't in your app
+ *
+ * Reference it with `get`, by its name, then subscribe to it.
+ *
+ * ```ts title="sst.config.ts"
+ * sst.aws.v5.Bus.get("Shared", "my-shared-bus").subscribe("MySubscriber", "src/subscriber.handler");
+ * ```
+ *
+ * #### Switch from `sst.aws.Bus`
+ *
+ * Change `sst.aws.Bus` to `sst.aws.v5.Bus` and keep the name. The bus and the subscribers
+ * you've deployed are kept.
+ *
+ * ```ts title="sst.config.ts" del={1} ins={2}
+ * const bus = new sst.aws.Bus("MyBus");
+ * const bus = new sst.aws.v5.Bus("MyBus");
+ * ```
+ *
+ * A few things work differently:
+ *
+ * - `sst.aws.Bus.subscribe` and `sst.aws.Bus.subscribeQueue`, which took the ARN of a bus
+ *   that isn't in your app, are `get` followed by `subscribe` or `subscribeQueue`. `get`
+ *   takes the bus's name. What they created is kept.
+ *
+ *   ```ts title="sst.config.ts" del={1} ins={2}
+ *   sst.aws.Bus.subscribe("MySubscriber", busArn, "src/subscriber.handler");
+ *   sst.aws.v5.Bus.get("Shared", "my-shared-bus").subscribe("MySubscriber", "src/subscriber.handler");
+ *   ```
+ *
+ * - A subscriber's `transform` is the bus's: its `rule` and `target` apply to every
+ *   subscriber, and a function there is given the subscriber's name.
+ * - A queue subscriber is created with the bus's `provider`. `sst.aws.Bus` created it with
+ *   your app's provider, whatever the bus was given. If your bus has a `provider` and a queue
+ *   subscribed to it, the queue's rule, target and policy are replaced on switch: remove the
+ *   subscriber and deploy before you switch, then add it back.
+ *
+ * #### Link the bus to a resource
+ *
+ * You can link the bus to other resources, like a function or your Next.js app.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.Nextjs("MyWeb", {
+ *   link: [bus]
+ * });
+ * ```
+ *
+ * Once linked, you can publish messages to the bus from your app.
+ *
+ * ```ts title="app/page.tsx" {1,9}
+ * import { Resource } from "sst";
+ * import { EventBridgeClient, PutEventsCommand } from "@aws-sdk/client-eventbridge";
+ *
+ * const eb = new EventBridgeClient({});
+ *
+ * await eb.send(new PutEventsCommand({
+ *   Entries: [
+ *     {
+ *       EventBusName: Resource.MyBus.name,
+ *       Source: "my.source",
+ *       Detail: JSON.stringify({ foo: "bar" })
+ *     }
+ *   ]
+ * }));
+ * ```
+ */
+export declare class Bus extends Bus_base {
+    constructor(name: string, args?: BusArgs, opts?: ComponentResourceOptions);
+    /**
+     * The ARN of the EventBus.
+     */
+    get arn(): import("@pulumi/pulumi").Output<string>;
+    /**
+     * The name of the EventBus.
+     */
+    get name(): import("@pulumi/pulumi").Output<string>;
+    /**
+     * Subscribe to this EventBus with a function.
+     *
+     * @param name The name of the subscriber.
+     * @param subscriber The function that'll be notified: its handler, its args, a function
+     * component, or the ARN of a function.
+     * @param args Configure the subscription.
+     *
+     * @example
+     *
+     * ```js title="sst.config.ts"
+     * bus.subscribe("MySubscriber", "src/subscriber.handler");
+     * ```
+     *
+     * Only receive some events with a pattern.
+     *
+     * ```js title="sst.config.ts"
+     * bus.subscribe("MySubscriber", "src/subscriber.handler", {
+     *   pattern: {
+     *     detailType: ["order.created", "order.updated"]
+     *   }
+     * });
+     * ```
+     */
+    subscribe(name: string, subscriber: FunctionDefinition, args?: BusSubscriberArgs): this;
+    /**
+     * Subscribe to this EventBus with an SQS Queue.
+     *
+     * @param name The name of the subscriber.
+     * @param queue The queue that'll be notified: a queue component, or the ARN of a queue.
+     * @param args Configure the subscription.
+     *
+     * @example
+     *
+     * ```js title="sst.config.ts"
+     * const queue = new sst.aws.v5.Queue("MyQueue");
+     *
+     * bus.subscribeQueue("MyQueue", queue);
+     * ```
+     */
+    subscribeQueue(name: string, queue: Input<string | OriginalQueue | Queue>, args?: BusSubscriberArgs): this;
+    private subscriberRule;
+    /**
+     * Reference an existing EventBus with its name. This is useful when you create a bus in
+     * one stage and want to share it in another, or to subscribe to a bus that isn't in your
+     * app. The bus is used the way it is: it isn't configured here.
+     *
+     * @param name The name of the component.
+     * @param busName The name of the existing EventBus.
+     * @param opts Component resource options.
+     *
+     * @example
+     *
+     * ```ts title="sst.config.ts"
+     * const bus = $app.stage === "frank"
+     *   ? sst.aws.v5.Bus.get("MyBus", "app-dev-MyBus")
+     *   : new sst.aws.v5.Bus("MyBus");
+     * ```
+     */
+    static get(name: string, busName: Input<string>, opts?: ComponentResourceOptions): Bus;
+    /**
+     * Linking a bus gives the linked resource its name and ARN, and permission
+     * to use it.
+     */
+    link(): {
+        properties: {
+            name: import("@pulumi/pulumi").Output<string>;
+            arn: import("@pulumi/pulumi").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";
+        }[];
+    };
+}
+export {};
+//# sourceMappingURL=bus.d.ts.map

package/platform/types/components/aws/v5/bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bus.d.ts","sourceRoot":"","sources":["../../../../../src/components/aws/v5/bus.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EAGzB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,MAAM,EAA6B,MAAM,uBAAuB,CAAC;AAC1E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EACL,KAAK,kBAAkB,EAExB,MAAM,0BAA0B,CAAC;AAIlC,OAAO,KAAK,EAAE,KAAK,IAAI,aAAa,EAAE,MAAM,UAAU,CAAC;AACvD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,EACV,OAAO,IAAI,eAAe,EAC1B,iBAAiB,IAAI,yBAAyB,EAC/C,MAAM,QAAQ,CAAC;AAEhB,QAAA,MAAM,KAAK;IACT;;OAEG;;IAEH;;OAEG;;IAEH;;;OAGG;;IAEH;;OAEG;;IAEH;;;OAGG;;IAEH;;;OAGG;;CAEH,CAAC;AAEH,MAAM,WAAW,OAAQ,SAAQ,MAAM,CAAC,eAAe,EAAE,OAAO,KAAK,CAAC;CAAG;AAEzE,MAAM,WAAW,iBACf,SAAQ,IAAI,CAAC,yBAAyB,EAAE,WAAW,CAAC;CAAG;;IAhCvD;;OAEG;;IAEH;;OAEG;;IAEH;;;OAGG;;IAEH;;OAEG;;IAEH;;;OAGG;;IAEH;;;OAGG;;;AASL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0FG;AACH,qBAAa,GAAI,SAAQ,QAA+B;gBAEpD,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,OAAY,EAClB,IAAI,CAAC,EAAE,wBAAwB;IAcjC;;OAEG;IACH,IAAW,GAAG,4CAEb;IAED;;OAEG;IACH,IAAW,IAAI,4CAEd;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACI,SAAS,CACd,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,kBAAkB,EAC9B,IAAI,GAAE,iBAAsB;IAqB9B;;;;;;;;;;;;;;OAcG;IACI,cAAc,CACnB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,KAAK,CAAC,MAAM,GAAG,aAAa,GAAG,KAAK,CAAC,EAC5C,IAAI,GAAE,iBAAsB;IAoB9B,OAAO,CAAC,cAAc;IAkBtB;;;;;;;;;;;;;;;;OAgBG;WACW,GAAG,CACf,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,EACtB,IAAI,CAAC,EAAE,wBAAwB;IAKjC;;;OAGG;IACI,IAAI;;;;;;;;;;;;;;;;;CAMZ"}

package/platform/types/components/aws/v5/cluster.d.ts

@@ -0,0 +1,167 @@
+import { ComponentResourceOptions } from "@pulumi/pulumi";
+import { V5Args } from "../../parts-component";
+import { type TakesVpc } from "../helpers/vpc";
+import type { ClusterArgs as OriginalClusterArgs, ClusterGetArgs } from "../cluster";
+declare const parts: {
+    /**
+     * The Amazon ECS Cluster.
+     */
+    cluster: typeof import("@pulumi/aws/ecs/cluster").Cluster;
+    /**
+     * The capacity providers the cluster's services and tasks can run on: Fargate and
+     * Fargate Spot. A cluster passed in `existing` keeps the ones it has, and this isn't
+     * created.
+     */
+    capacityProviders: typeof import("@pulumi/aws/ecs/clusterCapacityProviders").ClusterCapacityProviders;
+};
+export interface ClusterArgs extends V5Args<TakesVpc<OriginalClusterArgs>, typeof parts> {
+}
+declare const Cluster_base: import("../..").ComponentClass<{
+    /**
+     * The Amazon ECS Cluster.
+     */
+    cluster: typeof import("@pulumi/aws/ecs/cluster").Cluster;
+    /**
+     * The capacity providers the cluster's services and tasks can run on: Fargate and
+     * Fargate Spot. A cluster passed in `existing` keeps the ones it has, and this isn't
+     * created.
+     */
+    capacityProviders: typeof import("@pulumi/aws/ecs/clusterCapacityProviders").ClusterCapacityProviders;
+}>;
+/**
+ * The `Cluster` component lets you create an [ECS cluster](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/clusters.html)
+ * for your app.
+ *
+ * It takes the same args as [`sst.aws.Cluster`](/docs/component/aws/cluster) 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
+ *
+ * #### Create the cluster
+ *
+ * ```ts title="sst.config.ts"
+ * const vpc = new sst.aws.Vpc("MyVpc");
+ * const cluster = new sst.aws.v5.Cluster("MyCluster", { vpc });
+ * ```
+ *
+ * #### Add a service
+ *
+ * A [`Service`](/docs/component/aws/v5/service) is a set of containers that are always
+ * running, like a web or application server. They're restarted if they fail.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.Service("MyService", { cluster });
+ * ```
+ *
+ * #### Add a task
+ *
+ * A [`Task`](/docs/component/aws/v5/task) is a set of containers that's started for long
+ * running asynchronous work, like data processing.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.Task("MyTask", { cluster });
+ * ```
+ *
+ * #### Switch from `sst.aws.Cluster`
+ *
+ * Change `sst.aws.Cluster` to `sst.aws.v5.Cluster` and keep the name. The cluster you've
+ * deployed is kept, and so is everything that runs in it.
+ *
+ * ```ts title="sst.config.ts" del={1} ins={2}
+ * const cluster = new sst.aws.Cluster("MyCluster", { vpc });
+ * const cluster = new sst.aws.v5.Cluster("MyCluster", { vpc });
+ * ```
+ *
+ * A few things work differently:
+ *
+ * - Switch the services and tasks in the cluster first, or along with it. A
+ *   `sst.aws.v5.Service` and a `sst.aws.v5.Task` take either cluster. A
+ *   [`sst.aws.Service`](/docs/component/aws/service) and a
+ *   [`sst.aws.Task`](/docs/component/aws/task) are typed for `sst.aws.Cluster` alone.
+ * - The deprecated `addService` and `addTask` are gone. Create the service or the task,
+ *   and pass it the cluster. Those methods also gave it the cluster's `provider`, so pass
+ *   that along if the cluster has one.
+ * - `sst.aws.Cluster.v1` has no V5 form.
+ * - `get` takes any ECS cluster. `sst.aws.Cluster.get` refused one without the version
+ *   tag SST puts on the clusters it creates.
+ * - `nodes.cluster` is the cluster, not an output of it. `nodes` also has the capacity
+ *   providers.
+ * - If you set `tags` on the cluster with an object in `transform`, it keeps the tag SST
+ *   sets next to yours. It's added back when you switch.
+ */
+export declare class Cluster extends Cluster_base {
+    private network;
+    constructor(name: string, args: ClusterArgs, opts?: ComponentResourceOptions);
+    /**
+     * The cluster ID.
+     */
+    get id(): import("@pulumi/pulumi").Output<string>;
+    /**
+     * Where the cluster's services and tasks run: the `Vpc`, or the ids it was
+     * given in its place.
+     * @internal
+     */
+    get vpc(): import("..").Vpc | import("@pulumi/pulumi").Output<Required<Pick<{
+        id: import("../../input").Input<string>;
+        securityGroups: import("../../input").Input<import("../../input").Input<string>[]>;
+        serviceSubnets?: import("../../input").Input<import("../../input").Input<string>[]>;
+        containerSubnets?: import("../../input").Input<import("../../input").Input<string>[]>;
+        publicSubnets?: import("../../input").Input<import("../../input").Input<string>[]>;
+        loadBalancerSubnets: import("../../input").Input<import("../../input").Input<string>[]>;
+        cloudmapNamespaceId?: import("../../input").Input<string>;
+        cloudmapNamespaceName?: import("../../input").Input<string>;
+    }, "containerSubnets">> & Omit<{
+        id: import("../../input").Input<string>;
+        securityGroups: import("../../input").Input<import("../../input").Input<string>[]>;
+        serviceSubnets?: import("../../input").Input<import("../../input").Input<string>[]>;
+        containerSubnets?: import("../../input").Input<import("../../input").Input<string>[]>;
+        publicSubnets?: import("../../input").Input<import("../../input").Input<string>[]>;
+        loadBalancerSubnets: import("../../input").Input<import("../../input").Input<string>[]>;
+        cloudmapNamespaceId?: import("../../input").Input<string>;
+        cloudmapNamespaceName?: import("../../input").Input<string>;
+    }, "containerSubnets" | "serviceSubnets">>;
+    /** @internal */
+    addService(name: string): never;
+    /** @internal */
+    addTask(name: string): never;
+    /**
+     * Reference an existing ECS Cluster with the given ID. This is useful when you
+     * create a cluster in one stage and want to share it in another. It avoids
+     * having to create a new cluster in the other stage.
+     *
+     * :::tip
+     * You can use the `static get` method to share cluster across stages.
+     * :::
+     *
+     * @param name The name of the component.
+     * @param args The arguments to get the cluster.
+     * @param opts Resource options.
+     *
+     * @example
+     * Imagine you create a cluster in the `dev` stage. And in your personal stage `frank`,
+     * instead of creating a new cluster, you want to share the same cluster from `dev`.
+     *
+     * ```ts title="sst.config.ts"
+     * const cluster = $app.stage === "frank"
+     *   ? sst.aws.v5.Cluster.get("MyCluster", {
+     *       id: "arn:aws:ecs:us-east-1:123456789012:cluster/app-dev-MyCluster",
+     *       vpc,
+     *     })
+     *   : new sst.aws.v5.Cluster("MyCluster", { vpc });
+     * ```
+     *
+     * Here `arn:aws:ecs:us-east-1:123456789012:cluster/app-dev-MyCluster` is the ID of the
+     * cluster created in the `dev` stage. You can find these by outputting the cluster ID
+     * in the `dev` stage.
+     *
+     * ```ts title="sst.config.ts"
+     * return {
+     *   id: cluster.id,
+     * };
+     * ```
+     */
+    static get(name: string, args: ClusterGetArgs, opts?: ComponentResourceOptions): Cluster;
+}
+export {};
+//# sourceMappingURL=cluster.d.ts.map

package/platform/types/components/aws/v5/cluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cluster.d.ts","sourceRoot":"","sources":["../../../../../src/components/aws/v5/cluster.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAU,MAAM,gBAAgB,CAAC;AAElE,OAAO,EAAE,MAAM,EAAa,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,KAAK,QAAQ,EAAS,MAAM,gBAAgB,CAAC;AAEtD,OAAO,KAAK,EAEV,WAAW,IAAI,mBAAmB,EAClC,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB,QAAA,MAAM,KAAK;IACT;;OAEG;;IAEH;;;;OAIG;;CAEJ,CAAC;AAEF,MAAM,WAAW,WACf,SAAQ,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,KAAK,CAAC;CAAG;;IAb9D;;OAEG;;IAEH;;;;OAIG;;;AAOL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,qBAAa,OAAQ,SAAQ,YAAmC;IAC9D,OAAO,CAAC,OAAO,CAAyB;gBAGtC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,WAAW,EACjB,IAAI,CAAC,EAAE,wBAAwB;IAqBjC;;OAEG;IACH,IAAW,EAAE,4CAEZ;IAED;;;;OAIG;IACH,IAAW,GAAG;;;;;;;;;;;;;;;;;;+CAEb;IAED,gBAAgB;IACT,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAMtC,gBAAgB;IACT,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAMnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;WACW,GAAG,CACf,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,cAAc,EACpB,IAAI,CAAC,EAAE,wBAAwB;CAQlC"}

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

@@ -0,0 +1,69 @@
+import { ComponentResourceOptions } from "@pulumi/pulumi";
+import { V5Args } from "../../parts-component";
+import type { Input } from "../../input";
+import type { CognitoUserPoolClientArgs as OriginalCognitoUserPoolClientArgs } from "../cognito-user-pool";
+declare const parts: {
+    /**
+     * The Cognito User Pool client.
+     */
+    client: typeof import("@pulumi/aws/cognito/userPoolClient").UserPoolClient;
+};
+export interface CognitoUserPoolClientArgs extends V5Args<OriginalCognitoUserPoolClientArgs, typeof parts> {
+    /**
+     * The Cognito user pool ID.
+     */
+    userPool: Input<string>;
+}
+declare const CognitoUserPoolClient_base: import("../..").ComponentClass<{
+    /**
+     * The Cognito User Pool client.
+     */
+    client: typeof import("@pulumi/aws/cognito/userPoolClient").UserPoolClient;
+}>;
+/**
+ * The `CognitoUserPoolClient` component is a client of an [Amazon Cognito user pool](https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html).
+ *
+ * :::note
+ * This component is not intended to be created directly.
+ * :::
+ *
+ * It's what the `addClient` method of the `CognitoUserPool` component returns. A client is
+ * a component of its own, under the name you add it with, so you can link it.
+ *
+ * @example
+ *
+ * #### Link the client to a resource
+ *
+ * ```ts title="sst.config.ts"
+ * const client = userPool.addClient("Web");
+ *
+ * new sst.aws.Nextjs("MyWeb", {
+ *   link: [client]
+ * });
+ * ```
+ *
+ * The client's ID and secret are then available as `Resource.Web.id` and
+ * `Resource.Web.secret`.
+ */
+export declare class CognitoUserPoolClient extends CognitoUserPoolClient_base {
+    constructor(name: string, args: CognitoUserPoolClientArgs, opts?: ComponentResourceOptions);
+    /**
+     * The Cognito User Pool client ID.
+     */
+    get id(): import("@pulumi/pulumi").Output<string>;
+    /**
+     * The Cognito User Pool client secret.
+     */
+    get secret(): import("@pulumi/pulumi").Output<string>;
+    /**
+     * Linking a client gives the linked resource its ID and its secret.
+     */
+    link(): {
+        properties: {
+            id: import("@pulumi/pulumi").Output<string>;
+            secret: import("@pulumi/pulumi").Output<string>;
+        };
+    };
+}
+export {};
+//# sourceMappingURL=cognito-user-pool-client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cognito-user-pool-client.d.ts","sourceRoot":"","sources":["../../../../../src/components/aws/v5/cognito-user-pool-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAC;AAE1D,OAAO,EAAE,MAAM,EAAa,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EACV,yBAAyB,IAAI,iCAAiC,EAC/D,MAAM,sBAAsB,CAAC;AAE9B,QAAA,MAAM,KAAK;IACT;;OAEG;;CAEJ,CAAC;AAEF,MAAM,WAAW,yBACf,SAAQ,MAAM,CAAC,iCAAiC,EAAE,OAAO,KAAK,CAAC;IAC/D;;OAEG;IACH,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACzB;;IAZC;;OAEG;;;AAYL;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,qBAAsB,SAAQ,0BAG1C;gBAEG,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,yBAAyB,EAC/B,IAAI,CAAC,EAAE,wBAAwB;IAqBjC;;OAEG;IACH,IAAW,EAAE,4CAEZ;IAED;;OAEG;IACH,IAAW,MAAM,4CAEhB;IAED;;OAEG;IACI,IAAI;;;;;;CAKZ"}