@pulumi/pulumi 3.124.1-alpha.xf6bdf03 → 3.125.0-alpha.x6215d96

package/resource.d.ts

@@ -2,52 +2,60 @@ import { Input, Inputs, Output } from "./output";
 export declare type ID = string;
 export declare type URN = string;
 /**
- * createUrn computes a URN from the combination of a resource name, resource type, optional parent,
- * optional project and optional stack.
+ * {@link createUrn} computes a URN from the combination of a resource name,
+ * resource type, optional parent, optional project and optional stack.
  */
 export declare function createUrn(name: Input<string>, type: Input<string>, parent?: Resource | Input<URN>, project?: string, stack?: string): Output<string>;
 /**
- * allAliases computes the full set of aliases for a child resource given a set of aliases applied to the child and
- * parent resources. This includes the child resource's own aliases, as well as aliases inherited from the parent.
- * If there are N child aliases, and M parent aliases, there will be (M+1)*(N+1)-1 total aliases,
- * or, as calculated in the logic below, N+(M*(1+N)).
+ * {@link allAliases} computes the full set of aliases for a child resource
+ * given a set of aliases applied to the child and parent resources. This
+ * includes the child resource's own aliases, as well as aliases inherited from
+ * the parent. If there are N child aliases, and M parent aliases, there will be
+ * (M+1)*(N+1)-1 total aliases, or, as calculated in the logic below,
+ * N+(M*(1+N)).
  */
 export declare function allAliases(childAliases: Input<URN | Alias>[], childName: string, childType: string, parent: Resource, parentName: string): Output<URN>[];
 /**
- * Resource represents a class whose CRUD operations are implemented by a provider plugin.
+ * {@link Resource} represents a class whose CRUD operations are implemented by
+ * a provider plugin.
  */
 export declare abstract class Resource {
     /**
-     * A regexp for use with sourcePosition.
+     * A regexp for use with {@link sourcePosition}.
      */
     private static sourcePositionRegExp;
     /**
-     * urn is the stable logical URN used to distinctly address a resource, both before and after
-     * deployments.
+     * The stable logical URN used to distinctly address a resource, both before
+     * and after deployments.
      */
     readonly urn: Output<URN>;
     static isInstance(obj: any): obj is Resource;
     /**
-     * sourcePosition returns the source position of the user code that instantiated this resource.
+     * Returns the source position of the user code that instantiated this
+     * resource.
      *
      * This is somewhat brittle in that it expects a call stack of the form:
-     * - Resource class constructor
-     * - abstract Resource subclass constructor
-     * - concrete Resource subclass constructor
+     *
+     * - {@link Resource} class constructor
+     * - abstract {@link Resource} subclass constructor
+     * - concrete {@link Resource} subclass constructor
      * - user code
      *
-     * This stack reflects the expected class hierarchy of "cloud resource / component resource < customresource/componentresource < resource".
+     * This stack reflects the expected class hierarchy of:
+     *
+     * Resource > Custom/Component resource > Cloud/Component resource
      *
-     * For example, consider the AWS S3 Bucket resource. When user code instantiates a Bucket, the stack will look like
-     * this:
+     * For example, consider the AWS S3 Bucket resource. When user code
+     * instantiates a Bucket, the stack will look like this:
      *
      *     new Resource (/path/to/resource.ts:123:45)
      *     new CustomResource (/path/to/resource.ts:678:90)
      *     new Bucket (/path/to/bucket.ts:987:65)
      *     <user code> (/path/to/index.ts:4:3)
      *
-     * Because Node can only give us the stack trace as text, we parse out the source position using a regex that
-     * matches traces of this form (see stackTraceRegExp above).
+     * Because Node can only give us the stack trace as text, we parse out the
+     * source position using a regex that matches traces of this form (see
+     * the {@link sourcePositionRegExp} above).
      */
     private static sourcePosition;
     /**
@@ -55,55 +63,68 @@ export declare abstract class Resource {
      */
     getProvider(moduleMember: string): ProviderResource | undefined;
     /**
-     * Creates and registers a new resource object.  [t] is the fully qualified type token and
-     * [name] is the "name" part to use in creating a stable and globally unique URN for the object.
-     * dependsOn is an optional list of other resources that this resource depends on, controlling
-     * the order in which we perform resource operations.
+     * Creates and registers a new resource object. `t` is the fully qualified
+     * type token and `name` is the "name" part to use in creating a stable and
+     * globally unique URN for the object. `dependsOn` is an optional list of
+     * other resources that this resource depends on, controlling the order in
+     * which we perform resource operations.
      *
-     * @param t The type of the resource.
-     * @param name The _unique_ name of the resource.
-     * @param custom True to indicate that this is a custom resource, managed by a plugin.
-     * @param props The arguments to use to populate the new resource.
-     * @param opts A bag of options that control this resource's behavior.
-     * @param remote True if this is a remote component resource.
-     * @param dependency True if this is a synthetic resource used internally for dependency tracking.
+     * @param t
+     *  The type of the resource.
+     * @param name
+     *  The _unique_ name of the resource.
+     * @param custom
+     *  True to indicate that this is a custom resource, managed by a plugin.
+     * @param props
+     *  The arguments to use to populate the new resource.
+     * @param opts
+     *  A bag of options that control this resource's behavior.
+     * @param remote
+     *  True if this is a remote component resource.
+     * @param dependency
+     *  True if this is a synthetic resource used internally for dependency tracking.
      */
     constructor(t: string, name: string, custom: boolean, props?: Inputs, opts?: ResourceOptions, remote?: boolean, dependency?: boolean);
 }
 /**
- * Constant to represent the 'root stack' resource for a Pulumi application.  The purpose of this is
- * solely to make it easy to write an [Alias] like so:
+ * A constant to represent the "root stack" resource for a Pulumi application.
+ * The purpose of this is solely to make it easy to write an {@link Alias} like
+ * so:
  *
  * `aliases: [{ parent: rootStackResource }]`.
  *
- * This indicates that the prior name for a resource was created based on it being parented directly
- * by the stack itself and no other resources.  Note: this is equivalent to:
+ * This indicates that the prior name for a resource was created based on it
+ * being parented directly by the stack itself and no other resources. Note:
+ * this is equivalent to:
  *
  * `aliases: [{ parent: undefined }]`
  *
- * However, the former form is preferable as it is more self-descriptive, while the latter may look
- * a bit confusing and may incorrectly look like something that could be removed without changing
- * semantics.
+ * However, the former form is preferable as it is more self-descriptive, while
+ * the latter may look a bit confusing and may incorrectly look like something
+ * that could be removed without changing semantics.
  */
 export declare const rootStackResource: Resource;
 /**
- * Alias is a partial description of prior named used for a resource. It can be processed in the
- * context of a resource creation to determine what the full aliased URN would be.
+ * {@link Alias} is a partial description of prior names used for a resource. It
+ * can be processed in the context of a resource creation to determine what the
+ * full aliased URN would be.
  *
- * Note there is a semantic difference between properties being absent from this type and properties
- * having the `undefined` value. Specifically, there is a difference between:
+ * Note there is a semantic difference between properties being absent from this
+ * type and properties having the `undefined` value. Specifically, there is a
+ * difference between:
  *
  * ```ts
  * { name: "foo", parent: undefined } // and
  * { name: "foo" }
  * ```
  *
- * The presence of a property indicates if its value should be used.  If absent, then the value is
- * not used.  So, in the above while `alias.parent` is `undefined` for both, the first alias means
- * "the original urn had no parent" while the second alias means "use the current parent".
+ * The presence of a property indicates if its value should be used.  If absent,
+ * then the value is not used. So, in the above while `alias.parent` is
+ * `undefined` for both, the first alias means "the original URN had no parent"
+ * while the second alias means "use the current parent".
  *
- * Note: to indicate that a resource was previously parented by the root stack, it is recommended
- * that you use:
+ * Note: to indicate that a resource was previously parented by the root stack,
+ * it is recommended that you use:
  *
  * `aliases: [{ parent: pulumi.rootStackResource }]`
  *
@@ -113,33 +134,37 @@ export declare const rootStackResource: Resource;
  */
 export interface Alias {
     /**
-     * The previous name of the resource.  If not provided, the current name of the resource is
-     * used.
+     * The previous name of the resource. If not provided, the current name of
+     * the resource is used.
      */
     name?: Input<string>;
     /**
-     * The previous type of the resource.  If not provided, the current type of the resource is used.
+     * The previous type of the resource. If not provided, the current type of
+     * the resource is used.
      */
     type?: Input<string>;
     /**
-     * The previous parent of the resource.  If not provided (i.e. `{ name: "foo" }`), the current
-     * parent of the resource is used (`opts.parent` if provided, else the implicit stack resource
-     * parent).
+     * The previous parent of the resource. If not provided (i.e. `{ name: "foo"
+     * }`), the current parent of the resource is used (`opts.parent` if
+     * provided, else the implicit stack resource parent).
      *
      * To specify no original parent, use `{ parent: pulumi.rootStackResource }`.
      */
     parent?: Resource | Input<URN>;
     /**
-     * The previous stack of the resource.  If not provided, defaults to `pulumi.getStack()`.
+     * The previous stack of the resource. If not provided, defaults to
+     * `pulumi.getStack()`.
      */
     stack?: Input<string>;
     /**
-     * The previous project of the resource. If not provided, defaults to `pulumi.getProject()`.
+     * The previous project of the resource. If not provided, defaults to
+     * `pulumi.getProject()`.
      */
     project?: Input<string>;
 }
 /**
- * ResourceOptions is a bag of optional settings that control a resource's behavior.
+ * {@link ResourceOptions} is a bag of optional settings that control a
+ * resource's behavior.
  */
 export interface ResourceOptions {
     /**
@@ -239,52 +264,57 @@ export interface CustomTimeouts {
     delete?: string;
 }
 /**
- * ResourceTransformation is the callback signature for the `transformations` resource option.  A
- * transformation is passed the same set of inputs provided to the `Resource` constructor, and can
- * optionally return back alternate values for the `props` and/or `opts` prior to the resource
- * actually being created.  The effect will be as though those props and opts were passed in place
- * of the original call to the `Resource` constructor.  If the transformation returns undefined,
- * this indicates that the resource will not be transformed.
+ * {@link ResourceTransformation} is the callback signature for the
+ * `transformations` resource option.  A transformation is passed the same set
+ * of inputs provided to the {@link Resource} constructor, and can optionally
+ * return back alternate values for the `props` and/or `opts` prior to the
+ * resource actually being created.  The effect will be as though those props
+ * and opts were passed in place of the original call to the {@link Resource}
+ * constructor. If the transformation returns `undefined`, this indicates that
+ * the resource will not be transformed.
  */
 export declare type ResourceTransformation = (args: ResourceTransformationArgs) => ResourceTransformationResult | undefined;
 /**
- * ResourceTransform is the callback signature for the `transforms` resource option.  A
- * transform is passed the same set of inputs provided to the `Resource` constructor, and can
- * optionally return back alternate values for the `props` and/or `opts` prior to the resource
- * actually being created.  The effect will be as though those props and opts were passed in place
- * of the original call to the `Resource` constructor.  If the transform returns undefined,
- * this indicates that the resource will not be transformed.
+ * {@link ResourceTransform} is the callback signature for the `transforms`
+ * resource option.  A transform is passed the same set of inputs provided to
+ * the {@link Resource} constructor, and can optionally return back alternate
+ * values for the `props` and/or `opts` prior to the resource actually being
+ * created.  The effect will be as though those props and opts were passed in
+ * place of the original call to the {@link Resource} constructor.  If the
+ * transform returns `undefined`, this indicates that the resource will not be
+ * transformed.
  */
 export declare type ResourceTransform = (args: ResourceTransformArgs) => Promise<ResourceTransformResult | undefined> | ResourceTransformResult | undefined;
 /**
- * ResourceTransformArgs is the argument bag passed to a resource transform.
+ * {@link ResourceTransformArgs} is the argument bag passed to a resource transform.
  */
 export interface ResourceTransformArgs {
     /**
-     * If the resource is a custom or component resource.
+     * True if the resource is a custom resource, false if it is a component resource.
      */
     custom: boolean;
     /**
-     * The type of the Resource.
+     * The type of the resource.
      */
     type: string;
     /**
-     * The name of the Resource.
+     * The name of the resource.
      */
     name: string;
     /**
-     * The original properties passed to the Resource constructor.
+     * The original properties passed to the resource constructor.
      */
     props: Inputs;
     /**
-     * The original resource options passed to the Resource constructor.
+     * The original resource options passed to the resource constructor.
      */
     opts: ResourceOptions;
 }
 /**
- * ResourceTransformResult is the result that must be returned by a resource transformation
- * callback.  It includes new values to use for the `props` and `opts` of the `Resource` in place of
- * the originally provided values.
+ * {@link ResourceTransformResult} is the result that must be returned by a
+ * resource transform callback.  It includes new values to use for the
+ * `props` and `opts` of the {@link Resource} in place of the originally
+ * provided values.
  */
 export interface ResourceTransformResult {
     /**
@@ -297,34 +327,36 @@ export interface ResourceTransformResult {
     opts: ResourceOptions;
 }
 /**
- * ResourceTransformationArgs is the argument bag passed to a resource transformation.
+ * {@link ResourceTransformationArgs} is the argument bag passed to a resource
+ * transformation.
  */
 export interface ResourceTransformationArgs {
     /**
-     * The Resource instance that is being transformed.
+     * The {@link Resource} instance that is being transformed.
      */
     resource: Resource;
     /**
-     * The type of the Resource.
+     * The type of the resource.
      */
     type: string;
     /**
-     * The name of the Resource.
+     * The name of the resource.
      */
     name: string;
     /**
-     * The original properties passed to the Resource constructor.
+     * The original properties passed to the resource constructor.
      */
     props: Inputs;
     /**
-     * The original resource options passed to the Resource constructor.
+     * The original resource options passed to the resource constructor.
      */
     opts: ResourceOptions;
 }
 /**
- * ResourceTransformationResult is the result that must be returned by a resource transformation
- * callback.  It includes new values to use for the `props` and `opts` of the `Resource` in place of
- * the originally provided values.
+ * {@link ResourceTransformationResult} is the result that must be returned by a
+ * resource transformation callback.  It includes new values to use for the
+ * `props` and `opts` of the {@link Resource} in place of the originally
+ * provided values.
  */
 export interface ResourceTransformationResult {
     /**
@@ -337,165 +369,202 @@ export interface ResourceTransformationResult {
     opts: ResourceOptions;
 }
 /**
- * CustomResourceOptions is a bag of optional settings that control a custom resource's behavior.
+ * {@link CustomResourceOptions} is a bag of optional settings that control a
+ * custom resource's behavior.
  */
 export interface CustomResourceOptions extends ResourceOptions {
     /**
-     * When set to true, deleteBeforeReplace indicates that this resource should be deleted before its replacement
-     * is created when replacement is necessary.
+     * When set to true, indicates that this resource should be deleted before
+     * its replacement is created when replacement is necessary.
      */
     deleteBeforeReplace?: boolean;
     /**
-     * The names of outputs for this resource that should be treated as secrets. This augments the list that
-     * the resource provider and pulumi engine already determine based on inputs to your resource. It can be used
-     * to mark certain ouputs as a secrets on a per resource basis.
+     * The names of outputs for this resource that should be treated as secrets.
+     * This augments the list that the resource provider and Pulumi engine
+     * already determine based on inputs to your resource. It can be used to
+     * mark certain ouputs as a secrets on a per resource basis.
      */
     additionalSecretOutputs?: string[];
     /**
-     * When provided with a resource ID, import indicates that this resource's provider should import its state from
-     * the cloud resource with the given ID. The inputs to the resource's constructor must align with the resource's
-     * current state. Once a resource has been imported, the import property must be removed from the resource's
-     * options.
+     * When provided with a resource ID, indicates that this resource's provider
+     * should import its state from the cloud resource with the given ID. The
+     * inputs to the resource's constructor must align with the resource's
+     * current state. Once a resource has been imported, the import property
+     * must be removed from the resource's options.
      */
     import?: ID;
 }
 /**
- * ComponentResourceOptions is a bag of optional settings that control a component resource's behavior.
+ * {@link ComponentResourceOptions} is a bag of optional settings that control a
+ * component resource's behavior.
  */
 export interface ComponentResourceOptions extends ResourceOptions {
     /**
-     * An optional set of providers to use for child resources. Either keyed by package name (e.g.
-     * "aws"), or just provided as an array.  In the latter case, the package name will be retrieved
-     * from the provider itself.
+     * An optional set of providers to use for child resources. Either keyed by
+     * package name (e.g. "aws"), or just provided as an array.  In the latter
+     * case, the package name will be retrieved from the provider itself.
      *
      * Note: only a list should be used. Mapping keys are not respected.
      */
     providers?: Record<string, ProviderResource> | ProviderResource[];
 }
 /**
- * CustomResource is a resource whose create, read, update, and delete (CRUD) operations are managed
- * by performing external operations on some physical entity.  The engine understands how to diff
- * and perform partial updates of them, and these CRUD operations are implemented in a dynamically
+ * {@link CustomResource} is a resource whose create, read, update, and delete
+ * (CRUD) operations are managed by performing external operations on some
+ * physical entity.  The engine understands how to diff and perform partial
+ * updates of them, and these CRUD operations are implemented in a dynamically
  * loaded plugin for the defining package.
  */
 export declare abstract class CustomResource extends Resource {
     /**
-     * id is the provider-assigned unique ID for this managed resource.  It is set during
-     * deployments and may be missing (undefined) during planning phases.
+     * The provider-assigned unique ID for this managed resource. It is set
+     * during deployments and may be missing (undefined) during planning phases.
      */
     readonly id: Output<ID>;
     /**
-     * Returns true if the given object is an instance of CustomResource.  This is designed to work even when
-     * multiple copies of the Pulumi SDK have been loaded into the same process.
+     * Returns true if the given object is a {@link CustomResource}. This is
+     * designed to work even when multiple copies of the Pulumi SDK have been
+     * loaded into the same process.
      */
     static isInstance(obj: any): obj is CustomResource;
     /**
-     * Creates and registers a new managed resource.  t is the fully qualified type token and name
-     * is the "name" part to use in creating a stable and globally unique URN for the object.
-     * dependsOn is an optional list of other resources that this resource depends on, controlling
-     * the order in which we perform resource operations. Creating an instance does not necessarily
-     * perform a create on the physical entity which it represents, and instead, this is dependent
-     * upon the diffing of the new goal state compared to the current known resource state.
+     * Creates and registers a new managed resource. `t` is the fully qualified
+     * type token and `name` is the "name" part to use in creating a stable and
+     * globally unique URN for the object. `dependsOn` is an optional list of
+     * other resources that this resource depends on, controlling the order in
+     * which we perform resource operations. Creating an instance does not
+     * necessarily perform a create on the physical entity which it represents.
+     * Instead, this is dependent upon the diffing of the new goal state
+     * compared to the current known resource state.
      *
-     * @param t The type of the resource.
-     * @param name The _unique_ name of the resource.
-     * @param props The arguments to use to populate the new resource.
-     * @param opts A bag of options that control this resource's behavior.
-     * @param dependency True if this is a synthetic resource used internally for dependency tracking.
+     * @param t
+     *  The type of the resource.
+     * @param name
+     *  The _unique_ name of the resource.
+     * @param props
+     *  The arguments to use to populate the new resource.
+     * @param opts
+     *  A bag of options that control this resource's behavior.
+     * @param dependency
+     *  True if this is a synthetic resource used internally for dependency tracking.
      */
     constructor(t: string, name: string, props?: Inputs, opts?: CustomResourceOptions, dependency?: boolean);
 }
 /**
- * ProviderResource is a resource that implements CRUD operations for other custom resources. These resources are
- * managed similarly to other resources, including the usual diffing and update semantics.
+ * {@link ProviderResource} is a resource that implements CRUD operations for
+ * other custom resources. These resources are managed similarly to other
+ * resources, including the usual diffing and update semantics.
  */
 export declare abstract class ProviderResource extends CustomResource {
     static register(provider: ProviderResource | undefined): Promise<string | undefined>;
     /**
      * Creates and registers a new provider resource for a particular package.
      *
-     * @param pkg The package associated with this provider.
-     * @param name The _unique_ name of the provider.
-     * @param props The configuration to use for this provider.
-     * @param opts A bag of options that control this provider's behavior.
-     * @param dependency True if this is a synthetic resource used internally for dependency tracking.
+     * @param pkg
+     *  The package associated with this provider.
+     * @param name
+     *  The _unique_ name of the provider.
+     * @param props
+     *  The configuration to use for this provider.
+     * @param opts
+     *  A bag of options that control this provider's behavior.
+     * @param dependency
+     *  True if this is a synthetic resource used internally for dependency tracking.
      */
     constructor(pkg: string, name: string, props?: Inputs, opts?: ResourceOptions, dependency?: boolean);
 }
 /**
- * ComponentResource is a resource that aggregates one or more other child resources into a higher
- * level abstraction. The component resource itself is a resource, but does not require custom CRUD
- * operations for provisioning.
+ * {@link ComponentResource} is a resource that aggregates one or more other
+ * child resources into a higher level abstraction. The component resource
+ * itself is a resource, but does not require custom CRUD operations for
+ * provisioning.
  */
 export declare class ComponentResource<TData = any> extends Resource {
     /**
-     * Returns true if the given object is an instance of CustomResource.  This is designed to work even when
-     * multiple copies of the Pulumi SDK have been loaded into the same process.
+     * Returns true if the given object is a {@link CustomResource}. This is
+     * designed to work even when multiple copies of the Pulumi SDK have been
+     * loaded into the same process.
      */
     static isInstance(obj: any): obj is ComponentResource;
     /**
-     * Creates and registers a new component resource.  [type] is the fully qualified type token and
-     * [name] is the "name" part to use in creating a stable and globally unique URN for the object.
-     * [opts.parent] is the optional parent for this component, and [opts.dependsOn] is an optional
-     * list of other resources that this resource depends on, controlling the order in which we
-     * perform resource operations.
+     * Creates and registers a new component resource. `type` is the fully
+     * qualified type token and `name` is the "name" part to use in creating a
+     * stable and globally unique URN for the object. `opts.parent` is the
+     * optional parent for this component, and `opts.dependsOn` is an optional
+     * list of other resources that this resource depends on, controlling the
+     * order in which we perform resource operations.
      *
-     * @param type The type of the resource.
-     * @param name The _unique_ name of the resource.
-     * @param args Information passed to [initialize] method.
-     * @param opts A bag of options that control this resource's behavior.
-     * @param remote True if this is a remote component resource.
+     * @param type
+     *  The type of the resource.
+     * @param name
+     *  The _unique_ name of the resource.
+     * @param args
+     *  Information passed to [initialize] method.
+     * @param opts
+     *  A bag of options that control this resource's behavior.
+     * @param remote
+     *  True if this is a remote component resource.
      */
     constructor(type: string, name: string, args?: Inputs, opts?: ComponentResourceOptions, remote?: boolean);
     /**
-     * Can be overridden by a subclass to asynchronously initialize data for this Component
-     * automatically when constructed.  The data will be available immediately for subclass
-     * constructors to use.  To access the data use `.getData`.
+     * Can be overridden by a subclass to asynchronously initialize data for this component
+     * automatically when constructed. The data will be available immediately for subclass
+     * constructors to use. To access the data use {@link getData}.
      */
     protected initialize(args: Inputs): Promise<TData>;
     /**
-     * Retrieves the data produces by [initialize].  The data is immediately available in a
-     * derived class's constructor after the `super(...)` call to `ComponentResource`.
+     * Retrieves the data produces by {@link initialize}. The data is
+     * immediately available in a derived class's constructor after the
+     * `super(...)` call to `ComponentResource`.
      */
     protected getData(): Promise<TData>;
     /**
-     * registerOutputs registers synthetic outputs that a component has initialized, usually by
-     * allocating other child sub-resources and propagating their resulting property values.
+     * Registers synthetic outputs that a component has initialized, usually by
+     * allocating other child sub-resources and propagating their resulting
+     * property values.
      *
-     * ComponentResources can call this at the end of their constructor to indicate that they are
-     * done creating child resources.  This is not strictly necessary as this will automatically be
-     * called after the `initialize` method completes.
+     * Component resources can call this at the end of their constructor to
+     * indicate that they are done creating child resources.  This is not
+     * strictly necessary as this will automatically be called after the {@link
+     * initialize} method completes.
      */
     protected registerOutputs(outputs?: Inputs | Promise<Inputs> | Output<Inputs>): void;
 }
 /**
- * [mergeOptions] takes two ResourceOptions values and produces a new ResourceOptions with the
- * respective properties of `opts2` merged over the same properties in `opts1`.  The original
- * options objects will be unchanged.
+ * {@link mergeOptions} takes two {@link ResourceOptions} values and produces a new
+ * {@link ResourceOptions} with the respective properties of `opts2` merged over the
+ * same properties in `opts1`. The original options objects will be unchanged.
  *
  * Conceptually property merging follows these basic rules:
- *  1. if the property is a collection, the final value will be a collection containing the values
- *     from each options object.
- *  2. Simple scaler values from `opts2` (i.e. strings, numbers, bools) will replace the values of
- *     `opts1`.
- *  3. `opts2` can have properties explicitly provided with `null` or `undefined` as the value. If
- *     explicitly provided, then that will be the final value in the result.
- *  4. For the purposes of merging `dependsOn`, `provider` and `providers` are always treated as
- *     collections, even if only a single value was provided.
+ *
+ *  1. if the property is a collection, the final value will be a collection
+ *     containing the values from each options object.
+ *
+ *  2. Simple scaler values from `opts2` (i.e. strings, numbers, bools) will
+ *     replace the values of `opts1`.
+ *
+ *  3. `opts2` can have properties explicitly provided with `null` or
+ *     `undefined` as the value. If explicitly provided, then that will be the
+ *     final value in the result.
+ *
+ *  4. For the purposes of merging `dependsOn`, `provider` and `providers` are
+ *     always treated as collections, even if only a single value was provided.
  */
 export declare function mergeOptions(opts1: CustomResourceOptions | undefined, opts2: CustomResourceOptions | undefined): CustomResourceOptions;
 export declare function mergeOptions(opts1: ComponentResourceOptions | undefined, opts2: ComponentResourceOptions | undefined): ComponentResourceOptions;
 export declare function mergeOptions(opts1: ResourceOptions | undefined, opts2: ResourceOptions | undefined): ResourceOptions;
 /**
- * A DependencyResource is a resource that is used to indicate that an Output has a dependency on a particular
- * resource. These resources are only created when dealing with remote component resources.
+ * A {@link DependencyResource} is a resource that is used to indicate that an
+ * {@link Output} has a dependency on a particular resource. These resources are
+ * only created when dealing with remote component resources.
  */
 export declare class DependencyResource extends CustomResource {
     constructor(urn: URN);
 }
 /**
- * A DependencyProviderResource is a resource that is used by the provider SDK as a stand-in for a provider that
- * is only used for its reference. Its only valid properties are its URN and ID.
+ * A {@link DependencyProviderResource} is a resource that is used by the
+ * provider SDK as a stand-in for a provider that is only used for its
+ * reference. Its only valid properties are its URN and ID.
  */
 export declare class DependencyProviderResource extends ProviderResource {
     constructor(ref: string);