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

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

@@ -0,0 +1,407 @@
+import { ComponentResourceOptions, Output } from "@pulumi/pulumi";
+import { Plan, SsrSite, SsrSiteArgs } from "./ssr-site.js";
+export interface ReactArgs extends SsrSiteArgs {
+    /**
+     * Configure how this component works in `sst dev`.
+     *
+     * :::note
+     * In `sst dev` your React app is run in dev mode; it's not deployed.
+     * :::
+     *
+     * Instead of deploying your React 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 React 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 React app is located.  This path is relative to your `sst.config.ts`.
+     *
+     * By default it assumes your React app is in the root of your SST app.
+     * @default `"."`
+     *
+     * @example
+     *
+     * If your React app is in a package in your monorepo.
+     *
+     * ```js
+     * {
+     *   path: "packages/web"
+     * }
+     * ```
+     */
+    path?: SsrSiteArgs["path"];
+    /**
+     * [Link resources](/docs/linking/) to your React 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 React 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 [environment variables](https://vitejs.dev/guide/env-and-mode) in your React app. These are made available:
+     *
+     * 1. In `react-router build`, they are loaded into `process.env`.
+     * 2. Locally while running `react-router dev` through `sst dev`.
+     *
+     * Commands started by the build command inherit these variables. A standalone
+     * `vite preview` command runs outside SST; use
+     * `sst shell --target MyWeb -- vite preview` to expose them to the preview
+     * process. Client values in `import.meta.env` remain the values embedded by
+     * the build.
+     *
+     * :::tip
+     * You can also `link` resources to your React 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 React 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 React 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` as a:
+     *
+     * - A path like `/docs`
+     * - A subdomain like `docs.example.com`
+     * - Or a combined pattern like `dev.example.com/docs`
+     *
+     * @example
+     *
+     * To serve your React app **from a path**, you'll need to configure the root domain
+     * in your `Router` component.
+     *
+     * ```ts title="sst.config.ts" {2}
+     * const router = new sst.aws.Router("Router", {
+     *   domain: "example.com"
+     * });
+     * ```
+     *
+     * Now set the `router` and the `path`.
+     *
+     * ```ts {3,4}
+     * {
+     *   router: {
+     *     instance: router,
+     *     path: "/docs"
+     *   }
+     * }
+     * ```
+     *
+     * You also need to set the `base` property in your `vite.config.ts`.
+     *
+     * :::caution
+     * If routing to a path, you need to set that as the base path in your
+     * `vite.config.ts` and `reac-router.config.ts` as well.
+     * :::
+     *
+     * ```js title="vite.config.ts" {3}
+     * export default defineConfig({
+     *   plugins: [tailwindcss(), reactRouter(), tsconfigPaths()],
+     *   base: "/docs/"
+     * });
+     * ```
+     *
+     * And the `basename` in your React Router configuration.
+     *
+     * ```jsx title="react-router.config.ts" {2}
+     * export const routerConfig = {
+     *   basename: "/docs"
+     * };
+     * ```
+     *
+     * To serve your React 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"
+     *   }
+     * }
+     * ```
+     *
+     * Finally, to serve your React app **from a combined pattern** like
+     * `dev.example.com/docs`, you'll need to configure the domain in your `Router` to
+     * match the subdomain.
+     *
+     * ```ts title="sst.config.ts" {3,4}
+     * const router = new sst.aws.Router("Router", {
+     *   domain: {
+     *     name: "example.com",
+     *     aliases: ["*.example.com"]
+     *   }
+     * });
+     * ```
+     *
+     * And set the `domain` and the `path`.
+     *
+     * ```ts {4,5}
+     * {
+     *   router: {
+     *     instance: router,
+     *     domain: "dev.example.com",
+     *     path: "/docs"
+     *   }
+     * }
+     * ```
+     *
+     * Also, make sure to set the base path in your `vite.config.ts` and `basename`
+     * in your `react-router.config.ts`, like above.
+     */
+    router?: SsrSiteArgs["router"];
+    /**
+     * The command used internally to build your React app.
+     *
+     * @default `"npm run build"`
+     *
+     * @example
+     *
+     * If you want to use a different build command.
+     * ```js
+     * {
+     *   buildCommand: "yarn build"
+     * }
+     * ```
+     */
+    buildCommand?: SsrSiteArgs["buildCommand"];
+    /**
+     * Configure the React app to use an existing CloudFront cache policy. By default,
+     * a new cache policy is created. Note that CloudFront has a limit of 20 cache
+     * policies per account. 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 `React` component lets you deploy a React app built with [React Router](https://reactrouter.com/) app to AWS.
+ *
+ * @example
+ *
+ * #### Minimal example
+ *
+ * Deploy a React app that's in the project root.
+ *
+ * ```js
+ * new sst.aws.React("MyWeb");
+ * ```
+ *
+ * #### Change the path
+ *
+ * Deploys the React app in the `my-react-app/` directory.
+ *
+ * ```js {2}
+ * new sst.aws.React("MyWeb", {
+ *   path: "my-react-app/"
+ * });
+ * ```
+ *
+ * #### Add a custom domain
+ *
+ * Set a custom domain for your React app.
+ *
+ * ```js {2}
+ * new sst.aws.React("MyWeb", {
+ *   domain: "my-app.com"
+ * });
+ * ```
+ *
+ * #### Redirect www to apex domain
+ *
+ * Redirect `www.my-app.com` to `my-app.com`.
+ *
+ * ```js {4}
+ * new sst.aws.React("MyWeb", {
+ *   domain: {
+ *     name: "my-app.com",
+ *     redirects: ["www.my-app.com"]
+ *   }
+ * });
+ * ```
+ *
+ * #### Link resources
+ *
+ * [Link resources](/docs/linking/) to your React app. This will grant permissions
+ * to the resources and allow you to access it in your app.
+ *
+ * ```ts {4}
+ * const bucket = new sst.aws.Bucket("MyBucket");
+ *
+ * new sst.aws.React("MyWeb", {
+ *   link: [bucket]
+ * });
+ * ```
+ *
+ * You can use the [SDK](/docs/reference/sdk/) to access the linked resources
+ * in your React app.
+ *
+ * ```ts title="app/root.tsx"
+ * import { Resource } from "sst";
+ *
+ * console.log(Resource.MyBucket.name);
+ * ```
+ */
+export declare class React extends SsrSite {
+    constructor(name: string, args?: ReactArgs, opts?: ComponentResourceOptions);
+    protected normalizeBuildCommand(): void;
+    protected buildPlan(outputPath: Output<string>): Output<Plan>;
+    /**
+     * The URL of the React 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=react.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../../../src/components/aws/react.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,wBAAwB,EAAE,MAAM,EAAU,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE3D,MAAM,WAAW,SAAU,SAAQ,WAAW;IAC5C;;;;;;;;;;;;OAYG;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;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC,aAAa,CAAC,CAAC;IACzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyGG;IACH,MAAM,CAAC,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;IAC/B;;;;;;;;;;;;;OAaG;IACH,YAAY,CAAC,EAAE,WAAW,CAAC,cAAc,CAAC,CAAC;IAC3C;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC,aAAa,CAAC,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,qBAAa,KAAM,SAAQ,OAAO;gBAE9B,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,SAAc,EACpB,IAAI,GAAE,wBAA6B;IAKrC,SAAS,CAAC,qBAAqB;IAE/B,SAAS,CAAC,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC;IAuF7D;;;;;OAKG;IACH,IAAW,GAAG,mBAEb;CACF"}

package/platform/types/components/aws/realtime-lambda-subscriber.d.ts

@@ -0,0 +1,53 @@
+import { ComponentResourceOptions, Input, Output } from "@pulumi/pulumi";
+import { Component } from "../component";
+import { Function, FunctionArgs } from "./function.js";
+import { RealtimeSubscriberArgs } from "./realtime";
+export interface Args extends RealtimeSubscriberArgs {
+    /**
+     * The IoT WebSocket server to use.
+     */
+    iot: Input<{
+        /**
+         * The name of the Realtime component.
+         */
+        name: Input<string>;
+    }>;
+    /**
+     * The subscriber function.
+     */
+    subscriber: Input<string | FunctionArgs>;
+}
+/**
+ * The `RealtimeLambdaSubscriber` component is internally used by the `Realtime` component
+ * to add subscriptions to the [AWS IoT endpoint](https://docs.aws.amazon.com/iot/latest/developerguide/what-is-aws-iot.html).
+ *
+ * :::note
+ * This component is not intended to be created directly.
+ * :::
+ *
+ * You'll find this component returned by the `subscribe` method of the `Realtime` component.
+ */
+export declare class RealtimeLambdaSubscriber extends Component {
+    private readonly fn;
+    private readonly permission;
+    private readonly rule;
+    constructor(name: string, args: Args, opts?: ComponentResourceOptions);
+    /**
+     * The underlying [resources](/docs/components/#nodes) this component creates.
+     */
+    get nodes(): {
+        /**
+         * The Lambda function that'll be notified.
+         */
+        readonly function: Output<Function>;
+        /**
+         * The Lambda permission.
+         */
+        permission: import("@pulumi/aws/lambda/permission").Permission;
+        /**
+         * The IoT Topic rule.
+         */
+        rule: import("@pulumi/aws/iot/topicRule").TopicRule;
+    };
+}
+//# sourceMappingURL=realtime-lambda-subscriber.d.ts.map

package/platform/types/components/aws/realtime-lambda-subscriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime-lambda-subscriber.d.ts","sourceRoot":"","sources":["../../../../src/components/aws/realtime-lambda-subscriber.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,KAAK,EACL,MAAM,EAGP,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,SAAS,EAAa,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAKpD,MAAM,WAAW,IAAK,SAAQ,sBAAsB;IAClD;;OAEG;IACH,GAAG,EAAE,KAAK,CAAC;QACT;;WAEG;QACH,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;KACrB,CAAC,CAAC;IACH;;OAEG;IACH,UAAU,EAAE,KAAK,CAAC,MAAM,GAAG,YAAY,CAAC,CAAC;CAC1C;AAED;;;;;;;;;GASG;AACH,qBAAa,wBAAyB,SAAQ,SAAS;IACrD,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAkB;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;IAC/C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgB;gBAEzB,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,wBAAwB;IAyDrE;;OAEG;IACH,IAAW,KAAK;QAGZ;;WAEG;;QAIH;;WAEG;;QAEH;;WAEG;;MAGN;CACF"}

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

@@ -0,0 +1,237 @@
+import { ComponentResourceOptions, Output } from "@pulumi/pulumi";
+import { Component, Transform } from "../component";
+import { Link } from "../link";
+import type { Input } from "../input";
+import { Function, FunctionArgs, FunctionArn } from "./function.js";
+import { RealtimeLambdaSubscriber } from "./realtime-lambda-subscriber";
+import { iot } from "@pulumi/aws";
+export interface RealtimeArgs {
+    /**
+     * The Lambda function that'll be used to authorize the client on connection.
+     * @example
+     * ```js
+     * {
+     *   authorizer: "src/authorizer.handler"
+     * }
+     * ```
+     */
+    authorizer: Input<string | FunctionArgs>;
+    /**
+     * [Transform](/docs/components#transform) how this subscription creates its underlying
+     * resources.
+     */
+    transform?: {
+        /**
+         * Transform the IoT authorizer resource.
+         */
+        authorizer?: Transform<iot.AuthorizerArgs>;
+    };
+}
+export interface RealtimeSubscriberArgs {
+    /**
+     * Filter the topics that'll be processed by the subscriber.
+     *
+     * :::tip
+     * Learn more about [topic filters](https://docs.aws.amazon.com/iot/latest/developerguide/topics.html#topicfilters).
+     * :::
+     *
+     * @example
+     * Subscribe to a specific topic.
+     * ```js
+     * {
+     *   filter: `${$app.name}/${$app.stage}/chat/room1`
+     * }
+     * ```
+     *
+     * Subscribe to all topics under a prefix.
+     * ```js
+     * {
+     *   filter: `${$app.name}/${$app.stage}/chat/#`
+     * }
+     * ```
+     */
+    filter: Input<string>;
+    /**
+     * [Transform](/docs/components#transform) how this subscription creates its underlying
+     * resources.
+     */
+    transform?: {
+        /**
+         * Transform the IoT Topic rule resource.
+         */
+        topicRule?: Transform<iot.TopicRuleArgs>;
+    };
+}
+/**
+ * The `Realtime` component lets you publish and subscribe to messages in realtime.
+ *
+ * It offers a **topic-based** messaging network using [AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/what-is-aws-iot.html). Letting you publish and subscribe to messages using
+ * a WebSocket in the browser and your server.
+ *
+ * Also, provides an [SDK](#sdk) to authorize clients, grant permissions to subscribe, and
+ * publish to topics.
+ *
+ * :::note
+ * IoT is shared across all apps and stages in your AWS account. So you need to prefix the
+ * topics by the app and stage name.
+ * :::
+ *
+ * There is **only 1 IoT endpoint** per region per AWS account. Messages from all apps and
+ * stages are published to the same IoT endpoint. Make sure to prefix the topics by the
+ * app and stage name.
+ *
+ * @example
+ *
+ * #### Create a realtime endpoint
+ *
+ * ```ts title="sst.config.ts"
+ * const server = new sst.aws.Realtime("MyServer", {
+ *   authorizer: "src/authorizer.handler"
+ * });
+ * ```
+ *
+ * #### Authorize the client
+ *
+ * ```ts title="src/authorizer.ts" "realtime.authorizer"
+ * import { Resource } from "sst/aws";
+ * import { realtime } from "sst/aws/realtime";
+ *
+ * export const handler = realtime.authorizer(async (token) => {
+ *   // Validate the token
+ *
+ *   // Return the topics to subscribe and publish
+ *   return {
+ *     subscribe: [`${Resource.App.name}/${Resource.App.stage}/chat/room1`],
+ *     publish: [`${Resource.App.name}/${Resource.App.stage}/chat/room1`],
+ *   };
+ * });
+ * ```
+ *
+ * #### Publish and receive messages in your frontend
+ *
+ * ```ts title="app/page.tsx"
+ * import { Resource } from "sst/aws";
+ *
+ * const client = new mqtt.MqttClient();
+ * // Configure with
+ * // - Resource.Realtime.endpoint
+ * // - Resource.Realtime.authorizer
+ * const connection = client.new_connection(config);
+ *
+ * // Subscribe messages
+ * connection.on("message", (topic, payload) => {
+ *   // Handle the message
+ * });
+ *
+ * // Publish messages
+ * connection.publish(topic, payload, mqtt.QoS.AtLeastOnce);
+ * ```
+ *
+ * #### Subscribe messages in your backend
+ *
+ * ```ts title="sst.config.ts"
+ * server.subscribe("src/subscriber.handler", {
+ *   filter: `${$app.name}/${$app.stage}/chat/room1`
+ * });
+ * ```
+ *
+ * #### Publish message from your backend
+ *
+ * ```ts title="src/lambda.ts"
+ * import { IoTDataPlaneClient, PublishCommand } from "@aws-sdk/client-iot-data-plane";
+ * const data = new IoTDataPlaneClient();
+ * await data.send(
+ *   new PublishCommand({
+ *     payload: Buffer.from(
+ *       JSON.stringify({ message: "Hello world" })
+ *     ),
+ *     topic: `${Resource.App.name}/${Resource.App.stage}/chat/room1`,
+ *   })
+ * );
+ * ```
+ */
+export declare class Realtime extends Component implements Link.Linkable {
+    private readonly constructorName;
+    private constructorOpts;
+    private readonly authHadler;
+    private readonly iotAuthorizer;
+    private readonly iotEndpoint;
+    constructor(name: string, args: RealtimeArgs, opts?: ComponentResourceOptions);
+    /**
+     * The IoT endpoint.
+     */
+    get endpoint(): Output<string>;
+    /**
+     * The name of the IoT authorizer.
+     */
+    get authorizer(): Output<string>;
+    /**
+     * The underlying [resources](/docs/components/#nodes) this component creates.
+     */
+    get nodes(): {
+        /**
+         * The IoT authorizer resource.
+         */
+        authorizer: import("@pulumi/aws/iot/authorizer").Authorizer;
+        /**
+         * The IoT authorizer function resource.
+         */
+        authHandler: Output<Function>;
+    };
+    /**
+     * Subscribe to this Realtime server.
+     *
+     * @param subscriber The function that'll be notified.
+     * @param args Configure the subscription.
+     *
+     * @example
+     *
+     * ```js title="sst.config.ts"
+     * server.subscribe("src/subscriber.handler", {
+     *   filter: `${$app.name}/${$app.stage}/chat/room1`
+     * });
+     * ```
+     *
+     * Customize the subscriber function.
+     *
+     * ```js title="sst.config.ts"
+     * server.subscribe(
+     *   {
+     *     handler: "src/subscriber.handler",
+     *     timeout: "60 seconds"
+     *   },
+     *   {
+     *     filter: `${$app.name}/${$app.stage}/chat/room1`
+     *   }
+     * );
+     * ```
+     *
+     * Or pass in the ARN of an existing Lambda function.
+     *
+     * ```js title="sst.config.ts"
+     * server.subscribe("arn:aws:lambda:us-east-1:123456789012:function:my-function", {
+     *   filter: `${$app.name}/${$app.stage}/chat/room1`
+     * });
+     * ```
+     */
+    subscribe(subscriber: Input<string | FunctionArgs | FunctionArn>, args: RealtimeSubscriberArgs): Output<RealtimeLambdaSubscriber>;
+    /** @internal */
+    getSSTLink(): {
+        properties: {
+            endpoint: Output<string>;
+            authorizer: 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";
+        }[];
+    };
+}
+//# sourceMappingURL=realtime.d.ts.map