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

package/platform/types/components/linkable.d.ts

@@ -0,0 +1,301 @@
+import { Output } from "@pulumi/pulumi";
+import { Link } from "./link";
+import { Component } from "./component";
+import { Input } from "./input";
+export interface Definition<Properties extends Record<string, any> = Record<string, any>> {
+    /**
+     * Define values that the linked resource can access at runtime. These can be outputs
+     * from other resources or constants.
+     *
+     * @example
+     * ```ts
+     * {
+     *   properties: { foo: "bar" }
+     * }
+     * ```
+     */
+    properties: Properties;
+    /**
+     * Include AWS permissions or Cloudflare bindings for the linkable resource. The linked
+     * resource will have these permissions or bindings.
+     *
+     * @example
+     * Include AWS permissions.
+     *
+     * ```ts
+     * {
+     *   include: [
+     *     sst.aws.permission({
+     *       actions: ["lambda:InvokeFunction"],
+     *       resources: ["*"]
+     *     })
+     *   ]
+     * }
+     * ```
+     *
+     * Include Cloudflare bindings.
+     *
+     * ```ts
+     * {
+     *   include: [
+     *     sst.cloudflare.binding({
+     *       type: "r2BucketBindings",
+     *       properties: {
+     *         bucketName: "my-bucket"
+     *       }
+     *     })
+     *   ]
+     * }
+     * ```
+     */
+    include?: {
+        type: string;
+        [key: string]: any;
+    }[];
+}
+/**
+ * The `Linkable` component and the `Linkable.wrap` method lets you link any resources in your
+ * app; not just the built-in SST components. It also lets you modify the links SST creates.
+ *
+ * @example
+ *
+ * #### Linking any value
+ *
+ * The `Linkable` component takes a list of properties that you want to link. These can be
+ * outputs from other resources or constants.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.Linkable("MyLinkable", {
+ *   properties: { foo: "bar" }
+ * });
+ * ```
+ *
+ * You can also use this to combine multiple resources into a single linkable resource. And
+ * optionally include permissions or bindings for the linked resource.
+ *
+ * ```ts title="sst.config.ts"
+ * const bucketA = new sst.aws.Bucket("MyBucketA");
+ * const bucketB = new sst.aws.Bucket("MyBucketB");
+ *
+ * const storage = new sst.Linkable("MyStorage", {
+ *   properties: {
+ *     foo: "bar",
+ *     bucketA: bucketA.name,
+ *     bucketB: bucketB.name
+ *   },
+ *   include: [
+ *     sst.aws.permission({
+ *       actions: ["s3:*"],
+ *       resources: [bucketA.arn, bucketB.arn]
+ *     })
+ *   ]
+ * });
+ * ```
+ *
+ * You can now link this resource to your frontend or a function.
+ *
+ * ```ts title="sst.config.ts" {3}
+ * new sst.aws.Function("MyApi", {
+ *   handler: "src/lambda.handler",
+ *   link: [storage]
+ * });
+ * ```
+ *
+ * Then use the [SDK](/docs/reference/sdk/) to access it at runtime.
+ *
+ * ```js title="src/lambda.ts"
+ * import { Resource } from "sst";
+ *
+ * console.log(Resource.MyStorage.bucketA);
+ * ```
+ *
+ * #### Linking any resource
+ *
+ * You can also wrap any Pulumi Resource class to make it linkable.
+ *
+ * ```ts title="sst.config.ts"
+ * sst.Linkable.wrap(aws.dynamodb.Table, (table) => ({
+ *   properties: { tableName: table.name },
+ *   include: [
+ *     sst.aws.permission({
+ *       actions: ["dynamodb:*"],
+ *       resources: [table.arn]
+ *     })
+ *   ]
+ * }));
+ * ```
+ *
+ * Now you create an instance of `aws.dynamodb.Table` and link it in your app like any other SST
+ * component.
+ *
+ * ```ts title="sst.config.ts" {7}
+ * const table = new aws.dynamodb.Table("MyTable", {
+ *   attributes: [{ name: "id", type: "S" }],
+ *   hashKey: "id"
+ * });
+ *
+ * new sst.aws.Nextjs("MyWeb", {
+ *   link: [table]
+ * });
+ * ```
+ *
+ * And use the [SDK](/docs/reference/sdk/) to access it at runtime.
+ *
+ * ```js title="app/page.tsx"
+ * import { Resource } from "sst";
+ *
+ * console.log(Resource.MyTable.tableName);
+ * ```
+ *
+ * Your function will also have the permissions defined above.
+ *
+ * #### Modify built-in links
+ *
+ * You can also modify how SST creates links. For example, you might want to change the
+ * permissions of a linkable resource.
+ *
+ * ```ts title="sst.config.ts" "sst.aws.Bucket"
+ *  sst.Linkable.wrap(sst.aws.Bucket, (bucket) => ({
+ *    properties: { name: bucket.name },
+ *    include: [
+ *      sst.aws.permission({
+ *        actions: ["s3:GetObject"],
+ *        resources: [bucket.arn]
+ *      })
+ *    ]
+ *  }));
+ * ```
+ *
+ * This overrides the built-in link and lets you create your own.
+ *
+ * #### Exposing links as env vars
+ *
+ * If you want to pass link env vars to compute not managed by SST, like an ECS task
+ * definition or a Kubernetes pod, use `Linkable.env()`. It returns an `Output` of
+ * `SST_RESOURCE_*` env vars that you can pass to any provider.
+ * [Check out an example](/docs/examples/#aws-linkable-env).
+ */
+export declare class Linkable<T extends Record<string, any>> extends Component implements Link.Linkable {
+    private _name;
+    private _definition;
+    static wrappedResources: Set<string>;
+    constructor(name: string, definition: Definition<T>);
+    get name(): Output<string>;
+    get properties(): T;
+    /** @internal */
+    getSSTLink(): Definition<T>;
+    /**
+     * Wrap any resource class to make it linkable. Behind the scenes this modifies the
+     * prototype of the given class.
+     *
+     * :::tip
+     * Use `Linkable.wrap` to make any resource linkable.
+     * :::
+     *
+     * @param cls The resource class to wrap.
+     * @param cb A callback that returns the definition for the linkable resource.
+     *
+     * @example
+     *
+     * Here we are wrapping the [`aws.dynamodb.Table`](https://www.pulumi.com/registry/packages/aws/api-docs/dynamodb/table/)
+     * class to make it linkable.
+     *
+     * ```ts title="sst.config.ts"
+     * Linkable.wrap(aws.dynamodb.Table, (table) => ({
+     *   properties: { tableName: table.name },
+     *   include: [
+     *     sst.aws.permission({
+     *       actions: ["dynamodb:*"],
+     *       resources: [table.arn]
+     *     })
+     *   ]
+     * }));
+     * ```
+     *
+     * It's defining the properties that we want made accessible at runtime and the permissions
+     * that the linked resource should have.
+     *
+     * Now you can link any `aws.dynamodb.Table` instances in your app just like any other SST
+     * component.
+     *
+     * ```ts title="sst.config.ts" {7}
+     * const table = new aws.dynamodb.Table("MyTable", {
+     *   attributes: [{ name: "id", type: "S" }],
+     *   hashKey: "id",
+     * });
+     *
+     * new sst.aws.Nextjs("MyWeb", {
+     *   link: [table]
+     * });
+     * ```
+     *
+     * Since this applies to any resource, you can also use it to wrap SST components and modify
+     * how they are linked.
+     *
+     * ```ts title="sst.config.ts" "sst.aws.Bucket"
+     * sst.Linkable.wrap(sst.aws.Bucket, (bucket) => ({
+     *   properties: { name: bucket.name },
+     *   include: [
+     *     sst.aws.permission({
+     *       actions: ["s3:GetObject"],
+     *       resources: [bucket.arn]
+     *     })
+     *   ]
+     * }));
+     * ```
+     *
+     * This overrides the built-in link and lets you create your own.
+     *
+     * :::tip
+     * You can modify the permissions granted by a linked resource.
+     * :::
+     *
+     * In the above example, we're modifying the permissions to access a linked `sst.aws.Bucket`
+     * in our app.
+     */
+    static wrap<Resource>(cls: {
+        new (...args: any[]): Resource;
+    }, cb: (resource: Resource) => Definition): void;
+    /**
+     * Convert an array of resources into `SST_RESOURCE_*` environment variables so
+     * that `Resource.MyResource` works at runtime inside containers or functions
+     * deployed through an external provider.
+     *
+     * @param links Array of linkable resources.
+     *
+     * @example
+     *
+     * If the provider accepts a flat `Record<string, string>`, you can pass the
+     * output directly.
+     *
+     * ```ts title="sst.config.ts"
+     * const bucket = new sst.aws.Bucket("MyBucket");
+     *
+     * new vercel.Project("BadDecision", {
+     *   name: "bad-decision",
+     *   environment: sst.Linkable.env([bucket]),
+     * });
+     * ```
+     */
+    static env(links: Input<any[]>): Output<Record<string, string>>;
+}
+/**
+ * @deprecated
+ * Use sst.Linkable instead.
+ */
+export declare class Resource extends Component implements Link.Linkable {
+    private _properties;
+    private _name;
+    constructor(name: string, properties: any);
+    get name(): Output<string>;
+    get properties(): any;
+    /** @internal */
+    getSSTLink(): {
+        properties: any;
+    };
+}
+export declare function env(env: Record<string, Input<string>>): {
+    type: "environment";
+    env: Record<string, Input<string>>;
+};
+//# sourceMappingURL=linkable.d.ts.map

package/platform/types/components/linkable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linkable.d.ts","sourceRoot":"","sources":["../../../src/components/linkable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,MAAM,WAAW,UAAU,CACzB,UAAU,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAE5D;;;;;;;;;;OAUG;IACH,UAAU,EAAE,UAAU,CAAC;IACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,OAAO,CAAC,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACpB,EAAE,CAAC;CACL;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyHG;AACH,qBAAa,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CACjD,SAAQ,SACR,YAAW,IAAI,CAAC,QAAQ;IAExB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,WAAW,CAAgB;IAEnC,OAAc,gBAAgB,cAAqB;gBAEvC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;IAMnD,IAAW,IAAI,mBAEd;IAED,IAAW,UAAU,MAEpB;IAED,gBAAgB;IACT,UAAU;IAIjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoEG;WACW,IAAI,CAAC,QAAQ,EACzB,GAAG,EAAE;QAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,QAAQ,CAAA;KAAE,EACvC,EAAE,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,UAAU;IAUxC;;;;;;;;;;;;;;;;;;;;OAoBG;WACW,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAGvE;AAED;;;GAGG;AACH,qBAAa,QAAS,SAAQ,SAAU,YAAW,IAAI,CAAC,QAAQ;IAC9D,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,KAAK,CAAS;gBAEV,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG;IAczC,IAAW,IAAI,mBAEd;IAED,IAAW,UAAU,QAEpB;IAED,gBAAgB;IACT,UAAU;;;CAKlB;AAED,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;;;EAKrD"}

package/platform/types/components/naming-rules.d.ts

@@ -0,0 +1,32 @@
+import { Output } from "@pulumi/pulumi";
+/**
+ * How SST names each resource type that its components create: which arg
+ * holds the physical name, and how long that name may be.
+ *
+ * A type a built-in component uses has to be in one of the two lists here.
+ * Add types used by your own components with `sst.Component.naming()`.
+ */
+export type BuiltInNamingRule = [
+    field: string,
+    max: number,
+    options?: {
+        lower?: boolean;
+        replace?: (name: string) => string;
+        suffix?: (props: any) => Output<string>;
+    }
+];
+/**
+ * How a resource type gets its physical name: which arg holds the name and
+ * how long it may be. `false` leaves the name to the provider.
+ */
+export type NamingRule = false | {
+    field: string;
+    max: number;
+    lower?: boolean;
+    replace?: (name: string) => string;
+};
+/** Types whose physical name SST doesn't set. */
+export declare const UNPREFIXED_TYPES: Set<string>;
+/** Types whose physical name is prefixed with the app and stage. */
+export declare const NAMING_RULES: Record<string, BuiltInNamingRule>;
+//# sourceMappingURL=naming-rules.d.ts.map

package/platform/types/components/naming-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming-rules.d.ts","sourceRoot":"","sources":["../../../src/components/naming-rules.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAU,MAAM,gBAAgB,CAAC;AAEhD;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM;IACb,GAAG,EAAE,MAAM;IACX,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;QACnC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC;KACzC;CACF,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,UAAU,GAClB,KAAK,GACL;IACE,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CACpC,CAAC;AAEN,iDAAiD;AACjD,eAAO,MAAM,gBAAgB,aAiG3B,CAAC;AAEH,oEAAoE;AACpE,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAqK1D,CAAC"}

package/platform/types/components/naming.d.ts

@@ -0,0 +1,21 @@
+import { type ResourceTransformationArgs, type ResourceTransformationResult } from "@pulumi/pulumi";
+import { type NamingRule } from "./naming-rules.js";
+export declare function logicalName(name: string): string;
+export declare function physicalName(max: number, name: string, suffix?: string): string;
+export declare function prefixName(max: number, name: string): string;
+export declare function hashNumberToPrettyString(number: number, length: number): string;
+export declare function hashStringToPrettyString(str: string, length: number): string;
+export declare const PRETTY_CHARS = "abcdefhkmnorstuvwxz";
+export declare function registerNamingRule(type: string, rule: NamingRule): void;
+/**
+ * Checks the logical name of a resource created inside a component, and gives
+ * it a physical name prefixed with the app and stage.
+ *
+ * @param component The type and name of the component.
+ * @param args The resource being created inside it.
+ */
+export declare function nameResource(component: {
+    type: string;
+    name: string;
+}, args: ResourceTransformationArgs): ResourceTransformationResult | undefined;
+//# sourceMappingURL=naming.d.ts.map

package/platform/types/components/naming.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"naming.d.ts","sourceRoot":"","sources":["../../../src/components/naming.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,0BAA0B,EAC/B,KAAK,4BAA4B,EAClC,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAIL,KAAK,UAAU,EAChB,MAAM,mBAAmB,CAAC;AAE3B,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,UAGvC;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAW,UAa1E;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,UAwBnD;AAED,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAetE;AAED,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAKnE;AAED,eAAO,MAAM,YAAY,wBAAwB,CAAC;AAIlD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,QAEhE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EACzC,IAAI,EAAE,0BAA0B,GAC/B,4BAA4B,GAAG,SAAS,CAsF1C"}

package/platform/types/components/parts-component.d.ts

@@ -0,0 +1,241 @@
+import { type ComponentResourceOptions, type CustomResourceOptions, type Input, type Inputs, type Output, type ResourceTransformationArgs } from "@pulumi/pulumi";
+import { Component } from "./component";
+import { type CreatedKeys, type ManyKeys, type Nodes, type PartArgs, type PartClassOf, type Parts, type SingleKeys } from "./parts";
+import type { Permission } from "./aws/permission";
+import type { binding } from "./cloudflare/binding";
+import type { env } from "./linkable";
+export { type ComponentArgs, type V5Args, type DeferredPart, type Existing, type ManyPart, type ManyTransform, type NamedPart, type Nodes, type OptionalPart, type PartArgs, type Parts, type Transforms, deferred, many, named, optional, } from "./parts";
+export { type PartTransform, type PartialArgs } from "./transform";
+/**
+ * What a link grants besides its properties: an AWS permission from
+ * `sst.aws.permission()`, a Cloudflare binding from `sst.cloudflare.binding()`,
+ * or environment variables from `sst.env()`.
+ */
+export type LinkInclude = Permission | ReturnType<typeof binding> | ReturnType<typeof env>;
+/** What a component's `link()` returns. */
+export interface LinkDefinition {
+    /** Values readable at runtime through `Resource.<Name>`. */
+    properties: Record<string, any>;
+    /** Permissions, bindings and environment variables to grant. */
+    include?: LinkInclude[];
+}
+/**
+ * Define a component: its type and the parts it's made of. Extend the class
+ * this returns, and create the parts in the constructor.
+ *
+ * @example
+ * ```ts title="sst.config.ts"
+ * const parts = {
+ *   bucket: aws.s3.Bucket,
+ * };
+ *
+ * interface UploadsArgs extends sst.ComponentArgs<typeof parts> {
+ *   retention?: number;
+ * }
+ *
+ * class Uploads extends sst.component("acme:index:Uploads", parts) {
+ *   constructor(name: string, args: UploadsArgs = {}) {
+ *     super(name, args);
+ *     this.part("bucket", { forceDestroy: true });
+ *   }
+ * }
+ * ```
+ *
+ * @param type The component's type, as `<package>:<module>:<Name>`, like
+ * `acme:index:Uploads`. Pulumi's tools expect the three parts.
+ * @param parts The resources the component is made of. Pass a function that
+ * returns them when a part is another SST component and this is SST's own
+ * code: those files import each other, so the class may not exist yet when
+ * the file loads.
+ */
+export declare function component<P extends Parts>(type: string, parts: P | (() => P)): ComponentClass<P>;
+/**
+ * The class `component()` returns. It has a name so that a component in a
+ * published package can be compiled to a `.d.ts`: TypeScript can't write out
+ * an unnamed class that has private members.
+ */
+export interface ComponentClass<P extends Parts> extends Omit<typeof PartsComponent, "prototype"> {
+    new (name: string, args?: Inputs, opts?: ComponentResourceOptions): PartsComponent<P>;
+    /** @internal */
+    readonly __pulumiType: string;
+    /** @internal Only carries the type of the parts. */
+    readonly __parts?: P;
+}
+/**
+ * A component built from parts. `component()` returns a class that extends
+ * this one; that is the way to define a component.
+ *
+ * This class keeps track of the parts: what each is named, the user's
+ * `transform` and `existing` for it, where it lived in the component this one
+ * takes over from, and the resource it ends up as in `nodes`.
+ */
+export declare class PartsComponent<P extends Parts> extends Component {
+    /** The resource options the component was created with. */
+    protected readonly componentOpts: ComponentResourceOptions;
+    private readonly partClasses;
+    private readonly partTransforms;
+    private readonly partExisting;
+    private readonly partNodes;
+    private readonly partDeferred;
+    private readonly partNames;
+    private readonly partDelegated;
+    private runningLocally;
+    constructor(type: string, name: string, args: Inputs | undefined, opts: ComponentResourceOptions | undefined, parts: P);
+    /**
+     * Make this component linkable. Return what a function, worker or site gets
+     * when the component is passed in its `link`:
+     *
+     * - `properties` are readable at runtime as `Resource.<Name>`.
+     * - `include` grants access: AWS permissions with `sst.aws.permission()`,
+     *   Cloudflare bindings with `sst.cloudflare.binding()`, and extra
+     *   environment variables with `sst.env()`.
+     *
+     * @example
+     * ```ts
+     * link() {
+     *   return {
+     *     properties: { name: this.nodes.bucket.bucket },
+     *     include: [
+     *       sst.aws.permission({
+     *         actions: ["s3:GetObject"],
+     *         resources: [$interpolate`${this.nodes.bucket.arn}/*`],
+     *       }),
+     *     ],
+     *   };
+     * }
+     * ```
+     */
+    link?(): LinkDefinition;
+    /**
+     * The underlying resources this component creates.
+     */
+    get nodes(): Nodes<P>;
+    /**
+     * Create one of this component's parts.
+     *
+     * The resource is named after the component and the part, `MyQueue` and
+     * `queue` giving `MyQueueQueue`, or after the name the part is declared
+     * with in `named()`. The user's `transform` for the part is applied to
+     * `args`, and the resource is added to `nodes`.
+     *
+     * A part declared with `many()` also takes an id, which is added to the
+     * name: `this.part("subnet", "1", args)` creates `MyVpcSubnet1`.
+     *
+     * @param key The part to create, one of the keys this component declares.
+     * @param args The default args for the resource.
+     * @param opts Resource options. The parent is always this component.
+     */
+    protected part<K extends SingleKeys<P> & CreatedKeys<P>>(key: K, args: PartArgs<P[K]>, opts?: CustomResourceOptions): InstanceType<PartClassOf<P[K]>>;
+    protected part<K extends ManyKeys<P> & CreatedKeys<P>>(key: K, id: string, args: PartArgs<P[K]>, opts?: CustomResourceOptions): InstanceType<PartClassOf<P[K]>>;
+    /**
+     * The resource the user passed in `existing` for a part, looked up when
+     * they passed its id. `undefined` when they didn't pass one.
+     *
+     * `this.part()` already uses it. Call this when the component has more to do
+     * for a resource it didn't create.
+     */
+    protected existingPart<K extends SingleKeys<P>>(key: K): InstanceType<PartClassOf<P[K]>> | undefined;
+    protected existingPart<K extends ManyKeys<P>>(key: K, id: string): InstanceType<PartClassOf<P[K]>> | undefined;
+    /**
+     * Look up the resource of a part by its id, in place of creating it. This
+     * is for a component that references something already deployed and works
+     * out the ids of its other parts itself: from a tag, or a data source.
+     *
+     * @example
+     * ```ts
+     * const cluster = this.existingPart("cluster");
+     * if (cluster) this.lookupPart("secret", cluster.tags.apply((tags) => tags.secret));
+     * ```
+     *
+     * @param key The part to look up.
+     * @param resourceId The id the resource is looked up by.
+     */
+    protected lookupPart<K extends SingleKeys<P> & CreatedKeys<P>>(key: K, resourceId: Input<string>, opts?: CustomResourceOptions): InstanceType<PartClassOf<P[K]>>;
+    protected lookupPart<K extends ManyKeys<P> & CreatedKeys<P>>(key: K, id: string, resourceId: Input<string>, opts?: CustomResourceOptions): InstanceType<PartClassOf<P[K]>>;
+    /**
+     * Say that this component isn't deployed in `sst dev` because it runs
+     * locally there. Reading `nodes` then explains why a resource is missing.
+     *
+     * Call it in the one place the component handles dev mode, and return
+     * before creating the parts that aren't deployed there. A part that's
+     * created all the same, like the role the local process runs as, is in
+     * `nodes` as usual.
+     */
+    protected runsLocally(): void;
+    /**
+     * Check what a method that adds something to this component is given: a
+     * name that isn't taken, and no `transform` of its own. The component's
+     * `transform` is where each one is changed.
+     *
+     * @example
+     * ```ts
+     * this.assertNew("route", "route", id, args, ["handler", "integration", "route"]);
+     * ```
+     *
+     * @param what What's being added, for the error messages: "route".
+     * @param key The `many` part that has one for each.
+     * @param id Its name.
+     * @param args The args the method was called with.
+     * @param transforms The parts whose `transform` applies to it. Defaults to `key`.
+     */
+    protected assertNew(what: string, key: ManyKeys<P>, id: string, args?: object, transforms?: (keyof P & string)[]): void;
+    /**
+     * Resource options for something that creates resources under this
+     * component on its behalf, like a DNS adapter creating records. Those
+     * resources aren't parts: they're configured through what creates them, so
+     * they have no `transform` here and aren't in `nodes`.
+     *
+     * @example
+     * ```ts
+     * dns.createAlias(name, record, this.delegateOpts());
+     * ```
+     */
+    protected delegateOpts(): ComponentResourceOptions;
+    /**
+     * What a helper needs to create a part on this component's behalf: its
+     * name, the user's transform, and where to report the result. This is how
+     * `functionPart()` creates a deferred part.
+     *
+     * @internal
+     */
+    partHandle(key: string, id?: string): {
+        name: string;
+        transform: any;
+        opts: {
+            parent: Component;
+            aliases: ({
+                name: Input<string>;
+                parent: import("@pulumi/pulumi").Resource;
+            } | {
+                name: Input<string>;
+                parent?: undefined;
+            } | {
+                name: Input<string>;
+                parent: Output<string>;
+            })[];
+        };
+        /** What the user passed in `existing` for the part, as they passed it. */
+        existing: unknown;
+        /**
+         * Supply the part's entry in `nodes`. `node` is called when `nodes` is
+         * read, so it may fail when the resource was never created.
+         */
+        defer: (node: () => Output<unknown>) => void;
+    };
+    /**
+     * Check that a resource created directly under this component is one of
+     * its parts, and record it for `nodes`.
+     *
+     * @internal
+     */
+    protected childCreated(child: ResourceTransformationArgs): void;
+    private findPart;
+    private nodeOf;
+    private existingOf;
+    private lookUp;
+    private aliasesOf;
+    private nameOf;
+    private partName;
+    private transformOf;
+}
+//# sourceMappingURL=parts-component.d.ts.map

package/platform/types/components/parts-component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parts-component.d.ts","sourceRoot":"","sources":["../../../src/components/parts-component.ts"],"names":[],"mappings":"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"}