diff --git a/playground/TypeScriptAppHost/apphost.ts b/playground/TypeScriptAppHost/apphost.ts
index b169215d431..b7fa2419bda 100644
--- a/playground/TypeScriptAppHost/apphost.ts
+++ b/playground/TypeScriptAppHost/apphost.ts
@@ -10,7 +10,7 @@ console.log("Aspire TypeScript AppHost starting...\n");
 // Create the distributed application builder
 const builder = await createBuilder();
 
-var ec = await builder.executionContext.get();
+const ec = await builder.executionContext.get();
 
 const isPublishMode = await ec.isPublishMode.get();
 console.log(`isRunMode: ${await ec.isRunMode.get()}`);
@@ -19,20 +19,18 @@ console.log(`isPublishMode: ${isPublishMode}`);
 // Add Docker Compose environment for publishing
 await builder.addDockerComposeEnvironment("compose");
 
-var dir = await builder.appHostDirectory.get();
+const dir = await builder.appHostDirectory.get();
 console.log(`AppHost directory: ${dir}`);
 
 // Add PostgreSQL server and database
-const postgres = await builder.addPostgres("postgres");
-const db = await postgres.addDatabase("db");
-const localCancellation = new AbortController();
-const dbUriExpression = await db.uriExpression.get();
-const _dbUri = await dbUriExpression.getValue(localCancellation.signal);
+const postgres = builder.addPostgres("postgres");
+const db = postgres.addDatabase("db");
 
 console.log("Added PostgreSQL server with database 'db'");
 
 // Add Express API that connects to PostgreSQL (uses npm run dev with tsx)
-const api = await builder
+// No await needed — withReference/waitFor accept promises directly
+const api = builder
     .addNodeApp("api", "./express-api", "src/server.ts")
     .withRunScript("dev")
     .withHttpEndpoint({ env: "PORT" })
@@ -41,26 +39,26 @@ const api = await builder
 
 console.log("Added Express API with reference to PostgreSQL database");
 
-// Also keep Redis as an example of another service with persistent lifetime
-const cache = await builder
+// Redis
+builder
     .addRedis("cache")
     .withLifetime(ContainerLifetime.Persistent);
 
 console.log("Added Redis cache");
 
-// Add Vite frontend that connects to the API using the unified reference API
-await builder
+// Vite frontend — withReference/waitFor accept the un-awaited 'api' promise
+builder
     .addViteApp("frontend", "./vite-frontend")
     .withReference(api)
     .waitFor(api)
     .withEnvironment("CUSTOM_ENV", "value")
     .withEnvironmentCallback(async (ctx: EnvironmentCallbackContext) => {
-        // Custom environment callback logic
+        // await needed here because getEndpoint returns a value we use
         var ep = await api.getEndpoint("http");
-
         await ctx.environmentVariables.set("API_ENDPOINT", refExpr`${ep}`);
     });
 
 console.log("Added Vite frontend with reference to API");
 
+// build() flushes all pending promises before running
 await builder.build().run();
diff --git a/src/Aspire.Hosting.CodeGeneration.TypeScript/AtsTypeScriptCodeGenerator.cs b/src/Aspire.Hosting.CodeGeneration.TypeScript/AtsTypeScriptCodeGenerator.cs
index eee09d3b7bb..f3e2a280b59 100644
--- a/src/Aspire.Hosting.CodeGeneration.TypeScript/AtsTypeScriptCodeGenerator.cs
+++ b/src/Aspire.Hosting.CodeGeneration.TypeScript/AtsTypeScriptCodeGenerator.cs
@@ -267,6 +267,23 @@ private static string GetDtoInterfaceName(string typeId)
     /// For interface handle types, generated APIs accept any handle-bearing wrapper instance.
     /// For cancellation tokens, generated APIs accept either an AbortSignal or a transport-safe CancellationToken.
     /// </summary>
+    /// <remarks>
+    /// Handle types are widened to accept <c>Awaitable&lt;T&gt;</c> so callers can pass un-awaited
+    /// fluent chains directly. Examples:
+    /// <code>
+    /// // Input: RedisResource handle type
+    /// // Output: "Awaitable&lt;RedisResource&gt;"
+    ///
+    /// // Input: Union of string | RedisResource
+    /// // Output: "string | Awaitable&lt;RedisResource&gt;"
+    ///
+    /// // Input: CancellationToken type
+    /// // Output: "AbortSignal | CancellationToken"
+    ///
+    /// // Input: plain string type
+    /// // Output: "string"
+    /// </code>
+    /// </remarks>
     private string MapInputTypeToTypeScript(AtsTypeRef? typeRef)
     {
         if (typeRef?.Category == AtsTypeCategory.Union)
@@ -278,10 +295,17 @@ private string MapInputTypeToTypeScript(AtsTypeRef? typeRef)
         {
             if (TryMapInterfaceInputTypeToTypeScript(typeRef!) is { } interfaceInputType)
             {
-                return interfaceInputType;
+                return $"Awaitable<{interfaceInputType}>";
             }
 
-            return GetHandleReferenceInterfaceName();
+            var handleName = GetHandleReferenceInterfaceName();
+            return $"Awaitable<{handleName}>";
+        }
+
+        if (IsHandleType(typeRef) && _wrapperClassNames.TryGetValue(typeRef!.TypeId, out var className))
+        {
+            var ifaceName = GetInterfaceName(className);
+            return $"Awaitable<{ifaceName}>";
         }
 
         if (IsCancellationTokenType(typeRef))
@@ -299,11 +323,42 @@ private string MapInputUnionTypeToTypeScript(AtsTypeRef typeRef)
             throw new InvalidOperationException("Union input types must define at least one member type.");
         }
 
-        var memberTypes = typeRef.UnionTypes
-            .Select(MapInputTypeToTypeScript)
-            .Distinct();
+        // Build union structurally: each member is mapped individually.
+        // Handle types become Awaitable<T>, non-handle types pass through as-is.
+        var nonHandleTypes = new List<string>();
+        var handleTypeNames = new List<string>();
 
-        return string.Join(" | ", memberTypes);
+        foreach (var memberRef in typeRef.UnionTypes)
+        {
+            if (IsWidenedHandleType(memberRef))
+            {
+                // Get the base type name without Awaitable wrapper for combining
+                var baseName = IsInterfaceHandleType(memberRef) && TryMapInterfaceInputTypeToTypeScript(memberRef) is { } expanded
+                    ? expanded
+                    : MapTypeRefToTypeScript(memberRef);
+                nonHandleTypes.Add(baseName);
+                handleTypeNames.Add(baseName);
+            }
+            else
+            {
+                nonHandleTypes.Add(MapInputTypeToTypeScript(memberRef));
+            }
+        }
+
+        var allBaseTypes = nonHandleTypes
+            .SelectMany(t => t.Split(" | ", StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries))
+            .Distinct(StringComparer.Ordinal)
+            .ToList();
+
+        if (handleTypeNames.Count > 0)
+        {
+            var handleUnion = string.Join(" | ", handleTypeNames
+                .SelectMany(t => t.Split(" | ", StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries))
+                .Distinct(StringComparer.Ordinal));
+            return string.Join(" | ", allBaseTypes) + $" | Awaitable<{handleUnion}>";
+        }
+
+        return string.Join(" | ", allBaseTypes);
     }
 
     /// <summary>
@@ -316,13 +371,6 @@ private string MapParameterToTypeScript(AtsParameterInfo param)
             return GenerateCallbackTypeSignature(param.CallbackParameters, param.CallbackReturnType);
         }
 
-        if (param.Type?.Category == AtsTypeCategory.Union && param.Type.UnionTypes is { Count: > 0 })
-        {
-            return string.Join(" | ", param.Type.UnionTypes
-                .SelectMany(t => MapInputTypeToTypeScript(t).Split(" | ", StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries))
-                .Distinct(StringComparer.Ordinal));
-        }
-
         return MapInputTypeToTypeScript(param.Type);
     }
 
@@ -424,9 +472,14 @@ private static bool IsInterfaceHandleType(AtsTypeRef? typeRef)
     private static bool IsCancellationTokenType(AtsTypeRef? typeRef) => typeRef?.TypeId == AtsConstants.CancellationToken;
 
     private static string GetRpcArgumentValueExpression(string parameterName, AtsTypeRef? typeRef)
-        => IsCancellationTokenType(typeRef)
-            ? $"CancellationToken.fromValue({parameterName})"
-            : parameterName;
+    {
+        if (IsCancellationTokenType(typeRef))
+        {
+            return $"CancellationToken.fromValue({parameterName})";
+        }
+
+        return parameterName;
+    }
 
     private static string GetRpcArgumentEntry(string parameterName, AtsTypeRef? typeRef)
     {
@@ -525,7 +578,8 @@ private string GenerateAspireSdk(AtsContext context)
                 CapabilityError,
                 registerCallback,
                 wrapIfHandle,
-                registerHandleWrapper
+                registerHandleWrapper,
+                isPromiseLike
             } from './transport.js';
             import type { AspireClientRpc } from './transport.js';
 
@@ -538,6 +592,8 @@ private string GenerateAspireSdk(AtsContext context)
                 AspireDict,
                 AspireList
             } from './base.js';
+
+            import type { Awaitable } from './base.js';
             """);
         WriteLine();
 
@@ -799,6 +855,13 @@ private void GenerateDtoInterfaces(IReadOnlyList<AtsDtoTypeInfo> dtoTypes)
                 WriteLine($"    {propName}?: {tsType};");
             }
 
+            // Add client-only properties that don't exist in the C# DTO
+            if (dto.Name == "CreateBuilderOptions")
+            {
+                WriteLine("    /** When false, pre-flush rejected promises are not re-thrown by build(). Default: true. */");
+                WriteLine("    throwOnPendingRejections?: boolean;");
+            }
+
             WriteLine("}");
             WriteLine();
         }
@@ -1346,6 +1409,35 @@ private void GenerateBuilderClass(BuilderModel builder)
         GenerateThenableClass(builder);
     }
 
+    /// <summary>
+    /// Generates both an internal async method and a public fluent method for a builder capability.
+    /// </summary>
+    /// <remarks>
+    /// <para>Produces a pair of methods: a private <c>_*Internal</c> method that performs the RPC call,
+    /// and a public method that wraps it in a thenable promise class for fluent chaining.</para>
+    /// <para>Generated TypeScript (example for <c>withEnvironment</c> on <c>RedisResource</c>):</para>
+    /// <code>
+    /// /** @internal */
+    /// private async _withEnvironmentInternal(name: string, value: string): Promise&lt;RedisResource&gt; {
+    ///     const rpcArgs: Record&lt;string, unknown&gt; = { builder: this._handle, name, value };
+    ///     const result = await this._client.invokeCapability&lt;RedisResourceHandle&gt;('...', rpcArgs);
+    ///     return new RedisResourceImpl(result, this._client);
+    /// }
+    ///
+    /// withEnvironment(name: string, value: string): RedisResourcePromise {
+    ///     return new RedisResourcePromiseImpl(
+    ///         this._withEnvironmentInternal(name, value), this._client);
+    /// }
+    ///
+    /// // For build(), the public wrapper flushes pending promises first:
+    /// build(): DistributedApplicationPromise {
+    ///     const flushAndBuild = async () =&gt; { await this._client.flushPendingPromises(); return this._buildInternal(); };
+    ///     return new DistributedApplicationPromiseImpl(flushAndBuild(), this._client, false);
+    /// }
+    /// </code>
+    /// <para>When a parameter is a handle type, promise resolution is emitted before the RPC args
+    /// (e.g. <c>db = isPromiseLike(db) ? await db : db;</c>).</para>
+    /// </remarks>
     private void GenerateBuilderMethod(BuilderModel builder, AtsCapabilityInfo capability)
     {
         var methodName = capability.MethodName;
@@ -1419,7 +1511,7 @@ private void GenerateBuilderMethod(BuilderModel builder, AtsCapabilityInfo capab
             // Extract optional params from options object
             foreach (var param in optionalParams)
             {
-                WriteLine($"        const {param.Name} = options?.{param.Name};");
+                WriteLine($"        {(IsWidenedHandleType(param.Type) ? "let" : "const")} {param.Name} = options?.{param.Name};");
             }
 
             // Handle callback registration if any
@@ -1429,6 +1521,9 @@ private void GenerateBuilderMethod(BuilderModel builder, AtsCapabilityInfo capab
                 GenerateCallbackRegistration(callbackParam);
             }
 
+            // Resolve any promise-like handle parameters before building rpcArgs
+            GeneratePromiseResolution(capability.Parameters);
+
             // Build args object with conditional inclusion
             GenerateArgsObjectWithConditionals(targetParamName, requiredParams, optionalParams);
 
@@ -1466,6 +1561,9 @@ private void GenerateBuilderMethod(BuilderModel builder, AtsCapabilityInfo capab
             GenerateCallbackRegistration(callbackParam);
         }
 
+        // Resolve any promise-like handle parameters before building rpcArgs
+        GeneratePromiseResolution(capability.Parameters);
+
         // Build args object with conditional inclusion
         GenerateArgsObjectWithConditionals(targetParamName, requiredParams, optionalParams);
 
@@ -1500,18 +1598,154 @@ private void GenerateBuilderMethod(BuilderModel builder, AtsCapabilityInfo capab
         // Extract optional params from options object and forward to internal method
         foreach (var param in optionalParams)
         {
-            WriteLine($"        const {param.Name} = options?.{param.Name};");
+            WriteLine($"        {(IsWidenedHandleType(param.Type) ? "let" : "const")} {param.Name} = options?.{param.Name};");
         }
 
         // Forward all params to internal method
         var allParamNames = capability.Parameters.Select(p => p.Name);
-        Write($"        return new {promiseImplementationClass}(this.{internalMethodName}(");
-        Write(string.Join(", ", allParamNames));
-        WriteLine("));");
+        var internalCall = $"this.{internalMethodName}({string.Join(", ", allParamNames)})";
+
+        // For build(), flush pending promises before invoking the internal method.
+        // This must happen in the public wrapper (not _buildInternal) to avoid deadlock:
+        // the PromiseImpl constructor tracks the build promise, and if _buildInternal
+        // awaited flushPendingPromises, the flush would re-await the tracked build promise.
+        if (string.Equals(capability.MethodName, "build", StringComparison.OrdinalIgnoreCase))
+        {
+            WriteLine($"        const flushAndBuild = async () => {{ await this._client.flushPendingPromises(); return {internalCall}; }};");
+            // Don't track the build promise — it wraps flushPendingPromises which
+            // may throw AggregateError. Tracking it would re-add that error to
+            // _rejectedErrors, poisoning subsequent build() calls.
+            WriteLine($"        return new {promiseImplementationClass}(flushAndBuild(), this._client, false);");
+        }
+        else
+        {
+            WriteLine($"        return new {promiseImplementationClass}({internalCall}, this._client);");
+        }
         WriteLine("    }");
         WriteLine();
     }
 
+    /// <summary>
+    /// Generates promise resolution code for handle-type parameters that may be PromiseLike.
+    /// </summary>
+    /// <remarks>
+    /// For each parameter whose type is a handle (or union containing handles), emits a line
+    /// that awaits it if it is a <c>PromiseLike</c>. Non-handle and callback parameters are skipped.
+    /// <code>
+    /// // For a handle-type param 'db':
+    /// db = isPromiseLike(db) ? await db : db;
+    ///
+    /// // For a non-handle param 'name' (string): nothing emitted
+    /// </code>
+    /// </remarks>
+    private void GeneratePromiseResolution(IReadOnlyList<AtsParameterInfo> parameters, string indent = "        ")
+    {
+        foreach (var param in parameters)
+        {
+            if (param.IsCallback)
+            {
+                continue;
+            }
+
+            if (IsWidenedHandleType(param.Type))
+            {
+                WriteLine($"{indent}{param.Name} = isPromiseLike({param.Name}) ? await {param.Name} : {param.Name};");
+            }
+        }
+    }
+
+    /// <summary>
+    /// Generates promise resolution for a single named parameter.
+    /// </summary>
+    /// <remarks>
+    /// Used for property setters where only the <c>value</c> parameter needs resolution.
+    /// <code>
+    /// // For a handle-type 'value' parameter:
+    /// value = isPromiseLike(value) ? await value : value;
+    /// </code>
+    /// </remarks>
+    private void GeneratePromiseResolutionForParam(string paramName, AtsTypeRef? paramType, string indent = "        ")
+    {
+        if (IsWidenedHandleType(paramType))
+        {
+            WriteLine($"{indent}{paramName} = isPromiseLike({paramName}) ? await {paramName} : {paramName};");
+        }
+    }
+
+    /// <summary>
+    /// Checks if a type was widened to accept Awaitable&lt;T&gt; in input position.
+    /// Must match the widening logic in MapInputTypeToTypeScript exactly.
+    /// </summary>
+    private bool IsWidenedHandleType(AtsTypeRef? typeRef)
+    {
+        if (typeRef == null)
+        {
+            return false;
+        }
+
+        // Interface handles are always widened
+        if (IsInterfaceHandleType(typeRef))
+        {
+            return true;
+        }
+
+        // Concrete handles are only widened if they have a wrapper class name
+        // (excludes special types like ReferenceExpression that bypass widening)
+        if (IsHandleType(typeRef) && _wrapperClassNames.ContainsKey(typeRef.TypeId))
+        {
+            return true;
+        }
+
+        if (typeRef.Category == AtsTypeCategory.Union && typeRef.UnionTypes is { Count: > 0 })
+        {
+            return typeRef.UnionTypes.Any(IsWidenedHandleType);
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Generates promise resolution and args object construction in one step.
+    /// This is the unified helper used by builder methods, type class methods, context methods, and wrapper methods.
+    /// </summary>
+    /// <remarks>
+    /// Combines <see cref="GeneratePromiseResolution"/> with RPC args construction.
+    /// Required parameters are inlined in the object literal; optional parameters
+    /// are added conditionally.
+    /// <code>
+    /// // Example output for a method with required 'name', handle-type 'db', and optional 'timeout':
+    /// db = isPromiseLike(db) ? await db : db;
+    /// const rpcArgs: Record&lt;string, unknown&gt; = { builder: this._handle, name, db };
+    /// if (timeout !== undefined) rpcArgs.timeout = timeout;
+    /// </code>
+    /// </remarks>
+    private void GenerateResolveAndBuildArgs(
+        string targetParamName,
+        IReadOnlyList<AtsParameterInfo> allParams,
+        List<AtsParameterInfo> requiredParams,
+        List<AtsParameterInfo> optionalParams,
+        string indent = "        ")
+    {
+        // Resolve any promise-like handle parameters
+        GeneratePromiseResolution(allParams, indent);
+
+        // Build the required args inline
+        var requiredArgs = new List<string> { $"{targetParamName}: this._handle" };
+        foreach (var param in requiredParams)
+        {
+            requiredArgs.Add(GetRpcArgumentEntry(param));
+        }
+
+        WriteLine($"{indent}const rpcArgs: Record<string, unknown> = {{ {string.Join(", ", requiredArgs)} }};");
+
+        // Conditionally add optional params
+        foreach (var param in optionalParams)
+        {
+            var rpcExpression = GetRpcArgumentExpression(param);
+            WriteLine($"{indent}if ({param.Name} !== undefined) rpcArgs.{param.Name} = {rpcExpression};");
+        }
+    }
+
     /// <summary>
     /// Generates an args object with conditional inclusion of optional parameters.
     /// </summary>
@@ -1537,6 +1771,28 @@ private void GenerateArgsObjectWithConditionals(
         }
     }
 
+    /// <summary>
+    /// Generates a thenable wrapper class for a builder that enables fluent chaining.
+    /// </summary>
+    /// <remarks>
+    /// <para>The generated class implements both <c>PromiseLike</c> (via <c>then()</c>) and
+    /// all fluent methods of the builder, forwarding each call through the inner promise.</para>
+    /// <para>Generated TypeScript (example for <c>RedisResource</c>):</para>
+    /// <code>
+    /// class RedisResourcePromiseImpl implements RedisResourcePromise {
+    ///     constructor(private _promise: Promise&lt;RedisResource&gt;, private _client: AspireClientRpc) {
+    ///         _client.trackPromise(_promise);
+    ///     }
+    ///     then&lt;T1, T2&gt;(...): PromiseLike&lt;T1 | T2&gt; {
+    ///         return this._promise.then(...);
+    ///     }
+    ///     withEnvironment(name: string, value: string): RedisResourcePromise {
+    ///         return new RedisResourcePromiseImpl(
+    ///             this._promise.then(obj =&gt; obj.withEnvironment(name, value)), this._client);
+    ///     }
+    /// }
+    /// </code>
+    /// </remarks>
     private void GenerateThenableClass(BuilderModel builder)
     {
         var capabilities = builder.Capabilities.Where(c =>
@@ -1557,7 +1813,9 @@ private void GenerateThenableClass(BuilderModel builder)
         WriteLine($" * await builder.addSomething().withX().withY();");
         WriteLine($" */");
         WriteLine($"class {promiseImplementationClass} implements {promiseClass} {{");
-        WriteLine($"    constructor(private _promise: Promise<{builder.BuilderClassName}>) {{}}");
+        WriteLine($"    constructor(private _promise: Promise<{builder.BuilderClassName}>, private _client: AspireClientRpc, track = true) {{");
+        WriteLine($"        if (track) {{ _client.trackPromise(_promise); }}");
+        WriteLine($"    }}");
         WriteLine();
 
         // Generate then() for PromiseLike interface
@@ -1646,7 +1904,7 @@ private void GenerateThenableClass(BuilderModel builder)
                 // Forward to the public method on the underlying object, wrapping result in promise class
                 Write($"        return new {methodPromiseImplementationClass}(this._promise.then(obj => obj.{methodName}(");
                 Write(argsString);
-                WriteLine(")));");
+                WriteLine($")), this._client);");
                 WriteLine("    }");
             }
             WriteLine();
@@ -1675,6 +1933,25 @@ private void GenerateAspireClient(List<AtsCapabilityInfo> entryPoints)
         }
     }
 
+    /// <summary>
+    /// Generates an exported entry-point function that creates a builder via an async IIFE.
+    /// </summary>
+    /// <remarks>
+    /// <para>Entry-point functions are standalone exports (not class methods). They wrap the
+    /// RPC call in an async IIFE and return a thenable promise class for immediate chaining.</para>
+    /// <para>Generated TypeScript (example for <c>createBuilder</c>):</para>
+    /// <code>
+    /// export function createBuilder(client: AspireClientRpc): DistributedApplicationBuilderPromise {
+    ///     const promise = (async () =&gt; {
+    ///         const rpcArgs: Record&lt;string, unknown&gt; = { };
+    ///         const handle = await client.invokeCapability&lt;DistributedApplicationBuilderHandle&gt;(
+    ///             'aspire.capability.createBuilder', rpcArgs);
+    ///         return new DistributedApplicationBuilderImpl(handle, client);
+    ///     })();
+    ///     return new DistributedApplicationBuilderPromiseImpl(promise, client);
+    /// }
+    /// </code>
+    /// </remarks>
     private void GenerateEntryPointFunction(AtsCapabilityInfo capability)
     {
         var methodName = capability.MethodName;
@@ -1711,19 +1988,31 @@ private void GenerateEntryPointFunction(AtsCapabilityInfo capability)
             Write($"export function {methodName}(");
             Write(paramsString);
             WriteLine($"): {returnPromiseWrapper} {{");
+            // Use async IIFE to resolve promise-like handle params before RPC
+            WriteLine($"    const promise = (async () => {{");
+            // Resolve promise-like handle params
+            foreach (var param in capability.Parameters)
+            {
+                if (!param.IsCallback && IsWidenedHandleType(param.Type))
+                {
+                    WriteLine($"        {param.Name} = isPromiseLike({param.Name}) ? await {param.Name} : {param.Name};");
+                }
+            }
             var requiredArgs = requiredParams
                 .Select(param => GetRpcArgumentEntry(param, useRegisteredCallback: false))
                 .ToList();
-            WriteLine($"    const rpcArgs: Record<string, unknown> = {{ {string.Join(", ", requiredArgs)} }};");
+            WriteLine($"        const rpcArgs: Record<string, unknown> = {{ {string.Join(", ", requiredArgs)} }};");
             foreach (var param in optionalParams)
             {
-                WriteLine($"    if ({param.Name} !== undefined) rpcArgs.{param.Name} = {GetRpcArgumentExpression(param, useRegisteredCallback: false)};");
+                WriteLine($"        if ({param.Name} !== undefined) rpcArgs.{param.Name} = {GetRpcArgumentExpression(param, useRegisteredCallback: false)};");
             }
-            WriteLine($"    const promise = client.invokeCapability<{handleType}>(");
-            WriteLine($"        '{capability.CapabilityId}',");
-            WriteLine("        rpcArgs");
-            WriteLine($"    ).then(handle => new {returnWrapperImplementationClass}(handle, client));");
-            WriteLine($"    return new {returnPromiseImplementationClass}(promise);");
+            WriteLine($"        const handle = await client.invokeCapability<{handleType}>(");
+            WriteLine($"            '{capability.CapabilityId}',");
+            WriteLine("            rpcArgs");
+            WriteLine("        );");
+            WriteLine($"        return new {returnWrapperImplementationClass}(handle, client);");
+            WriteLine($"    }})();");
+            WriteLine($"    return new {returnPromiseImplementationClass}(promise, client);");
             WriteLine("}");
         }
         else
@@ -1736,6 +2025,14 @@ private void GenerateEntryPointFunction(AtsCapabilityInfo capability)
             Write($"export async function {methodName}(");
             Write(paramsString);
             WriteLine($"): Promise<{returnType}> {{");
+            // Resolve promise-like handle params
+            foreach (var param in capability.Parameters)
+            {
+                if (!param.IsCallback && IsWidenedHandleType(param.Type))
+                {
+                    WriteLine($"    {param.Name} = isPromiseLike({param.Name}) ? await {param.Name} : {param.Name};");
+                }
+            }
             var requiredArgs = requiredParams
                 .Select(param => GetRpcArgumentEntry(param, useRegisteredCallback: false))
                 .ToList();
@@ -1967,6 +2264,11 @@ export async function connect(): Promise<AspireClientRpc> {
             export async function createBuilder(options?: CreateBuilderOptions): Promise<DistributedApplicationBuilder> {
                 const client = await connect();
 
+                // Apply client-side options before any tracking begins
+                if (options?.throwOnPendingRejections === false) {
+                    client.throwOnPendingRejections = false;
+                }
+
                 // Default args, projectDirectory, and appHostFilePath if not provided
                 // ASPIRE_APPHOST_FILEPATH is set by the CLI for consistent socket hash computation
                 const effectiveOptions: CreateBuilderOptions = {
@@ -1976,6 +2278,9 @@ export async function createBuilder(options?: CreateBuilderOptions): Promise<Dis
                     appHostFilePath: options?.appHostFilePath ?? process.env.ASPIRE_APPHOST_FILEPATH
                 };
 
+                // Strip client-only options before sending to the host
+                delete effectiveOptions.throwOnPendingRejections;
+
                 const handle = await client.invokeCapability<{{builderHandle}}>(
                     'Aspire.Hosting/createBuilderWithOptions',
                     { options: effectiveOptions }
@@ -1986,7 +2291,7 @@ export async function createBuilder(options?: CreateBuilderOptions): Promise<Dis
             // Re-export commonly used types
             export { Handle, AppHostUsageError, CancellationToken, CapabilityError, registerCallback } from './transport.js';
             export { refExpr, ReferenceExpression } from './base.js';
-            export type { HandleReference } from './base.js';
+            export type { HandleReference, Awaitable } from './base.js';
             """);
         WriteLine();
     }
@@ -2217,6 +2522,25 @@ private static string ExtractPropertyName(string methodName)
     /// Generates a property-like object with get and/or set methods.
     /// For dictionary types, generates a direct AspireDict field instead.
     /// </summary>
+    /// <remarks>
+    /// <para>Scalar properties produce an object with async <c>get</c>/<c>set</c> functions.
+    /// Dictionary and list properties delegate to <c>AspireDict</c>/<c>AspireList</c> helpers.
+    /// Wrapper-typed properties delegate to <see cref="GenerateWrapperPropertyObject"/>.</para>
+    /// <para>Generated TypeScript (example for a string property <c>connectionString</c>):</para>
+    /// <code>
+    /// connectionString = {
+    ///     get: async (): Promise&lt;string&gt; =&gt; {
+    ///         return await this._client.invokeCapability&lt;string&gt;(
+    ///             'aspire.resource.connectionString.get', { context: this._handle });
+    ///     },
+    ///     set: async (value: string | PromiseLike&lt;string&gt;): Promise&lt;void&gt; =&gt; {
+    ///         value = isPromiseLike(value) ? await value : value;
+    ///         await this._client.invokeCapability&lt;void&gt;(
+    ///             'aspire.resource.connectionString.set', { context: this._handle, value });
+    ///     }
+    /// };
+    /// </code>
+    /// </remarks>
     private void GeneratePropertyLikeObject(string propertyName, AtsCapabilityInfo? getter, AtsCapabilityInfo? setter)
     {
         // Determine the return type from getter
@@ -2288,6 +2612,7 @@ private void GeneratePropertyLikeObject(string propertyName, AtsCapabilityInfo?
             {
                 var valueType = MapInputTypeToTypeScript(valueParam.Type);
                 WriteLine($"        set: async (value: {valueType}): Promise<void> => {{");
+                GeneratePromiseResolutionForParam("value", valueParam.Type, "            ");
                 WriteLine($"            await this._client.invokeCapability<void>(");
                 WriteLine($"                '{setter.CapabilityId}',");
                 WriteLine($"                {{ context: this._handle, {GetRpcArgumentEntry("value", valueParam.Type)} }}");
@@ -2303,6 +2628,26 @@ private void GeneratePropertyLikeObject(string propertyName, AtsCapabilityInfo?
     /// <summary>
     /// Generates a property-like object that returns a wrapper class.
     /// </summary>
+    /// <remarks>
+    /// Similar to <see cref="GeneratePropertyLikeObject"/> but the getter returns a wrapper
+    /// class instance instead of a scalar value. The RPC result is a handle that gets
+    /// wrapped in the implementation class.
+    /// <code>
+    /// // Example: a property 'primaryEndpoint' returning EndpointReference
+    /// primaryEndpoint = {
+    ///     get: async (): Promise&lt;EndpointReference&gt; =&gt; {
+    ///         const handle = await this._client.invokeCapability&lt;EndpointReferenceHandle&gt;(
+    ///             'aspire.resource.primaryEndpoint.get', { context: this._handle });
+    ///         return new EndpointReferenceImpl(handle, this._client);
+    ///     },
+    ///     set: async (value: EndpointReference | PromiseLike&lt;EndpointReference&gt;): Promise&lt;void&gt; =&gt; {
+    ///         value = isPromiseLike(value) ? await value : value;
+    ///         await this._client.invokeCapability&lt;void&gt;(
+    ///             'aspire.resource.primaryEndpoint.set', { context: this._handle, value });
+    ///     }
+    /// };
+    /// </code>
+    /// </remarks>
     private void GenerateWrapperPropertyObject(string propertyName, AtsCapabilityInfo getter, AtsCapabilityInfo? setter, string wrapperClassName)
     {
         var handleType = GetHandleTypeName(getter.ReturnType!.TypeId);
@@ -2329,6 +2674,7 @@ private void GenerateWrapperPropertyObject(string propertyName, AtsCapabilityInf
             {
                 var valueType = MapInputTypeToTypeScript(valueParam.Type);
                 WriteLine($"        set: async (value: {valueType}): Promise<void> => {{");
+                GeneratePromiseResolutionForParam("value", valueParam.Type, "            ");
                 WriteLine($"            await this._client.invokeCapability<void>(");
                 WriteLine($"                '{setter.CapabilityId}',");
                 WriteLine($"                {{ context: this._handle, {GetRpcArgumentEntry("value", valueParam.Type)} }}");
@@ -2443,6 +2789,19 @@ private void GenerateListProperty(string propertyName, AtsCapabilityInfo getter)
     /// <summary>
     /// Generates a context instance method (from ExposeMethods=true).
     /// </summary>
+    /// <remarks>
+    /// <para>Context methods are async methods on wrapper classes that pass <c>this._handle</c>
+    /// as the context argument. They use <see cref="GenerateResolveAndBuildArgs"/> for parameter
+    /// handling.</para>
+    /// <para>Generated TypeScript (example for <c>getEndpoint</c> on <c>PostgresResource</c>):</para>
+    /// <code>
+    /// async getEndpoint(name: string): Promise&lt;EndpointReference&gt; {
+    ///     const rpcArgs: Record&lt;string, unknown&gt; = { context: this._handle, name };
+    ///     return await this._client.invokeCapability&lt;EndpointReference&gt;(
+    ///         'aspire.resource.getEndpoint', rpcArgs);
+    /// }
+    /// </code>
+    /// </remarks>
     private void GenerateContextMethod(AtsCapabilityInfo method)
     {
         // Use OwningTypeName if available to extract method name, otherwise parse from MethodName
@@ -2488,20 +2847,11 @@ private void GenerateContextMethod(AtsCapabilityInfo method)
         // Extract optional params from options object
         foreach (var param in optionalParams)
         {
-            WriteLine($"        const {param.Name} = options?.{param.Name};");
+            WriteLine($"        {(IsWidenedHandleType(param.Type) ? "let" : "const")} {param.Name} = options?.{param.Name};");
         }
 
-        // Build args object with conditional inclusion
-        var requiredArgs = new List<string> { $"{targetParamName}: this._handle" };
-        foreach (var param in requiredParams)
-        {
-            requiredArgs.Add(GetRpcArgumentEntry(param.Name, param.Type));
-        }
-        WriteLine($"        const rpcArgs: Record<string, unknown> = {{ {string.Join(", ", requiredArgs)} }};");
-        foreach (var param in optionalParams)
-        {
-            WriteLine($"        if ({param.Name} !== undefined) rpcArgs.{param.Name} = {GetRpcArgumentValueExpression(param.Name, param.Type)};");
-        }
+        // Resolve promise-like params and build args
+        GenerateResolveAndBuildArgs(targetParamName, userParams, requiredParams, optionalParams);
 
         if (returnType == "void")
         {
@@ -2532,6 +2882,18 @@ private void GenerateContextMethod(AtsCapabilityInfo method)
     /// <summary>
     /// Generates a method on a wrapper class.
     /// </summary>
+    /// <remarks>
+    /// <para>Similar to <see cref="GenerateContextMethod"/> but designed for wrapper classes
+    /// that expose RPC methods without the thenable/fluent pattern.</para>
+    /// <para>Generated TypeScript (example for <c>getExpression</c> on <c>EndpointReference</c>):</para>
+    /// <code>
+    /// async getExpression(name: string): Promise&lt;string&gt; {
+    ///     const rpcArgs: Record&lt;string, unknown&gt; = { builder: this._handle, name };
+    ///     return await this._client.invokeCapability&lt;string&gt;(
+    ///         'aspire.endpoint.getExpression', rpcArgs);
+    /// }
+    /// </code>
+    /// </remarks>
     private void GenerateWrapperMethod(AtsCapabilityInfo capability)
     {
         var methodName = GetTypeScriptMethodName(capability.MethodName);
@@ -2574,20 +2936,11 @@ private void GenerateWrapperMethod(AtsCapabilityInfo capability)
         // Extract optional params from options object
         foreach (var param in optionalParams)
         {
-            WriteLine($"        const {param.Name} = options?.{param.Name};");
+            WriteLine($"        {(IsWidenedHandleType(param.Type) ? "let" : "const")} {param.Name} = options?.{param.Name};");
         }
 
-        // Build args object with conditional inclusion
-        var requiredArgs = new List<string> { $"{firstParamName}: this._handle" };
-        foreach (var param in requiredParams)
-        {
-            requiredArgs.Add(GetRpcArgumentEntry(param.Name, param.Type));
-        }
-        WriteLine($"        const rpcArgs: Record<string, unknown> = {{ {string.Join(", ", requiredArgs)} }};");
-        foreach (var param in optionalParams)
-        {
-            WriteLine($"        if ({param.Name} !== undefined) rpcArgs.{param.Name} = {GetRpcArgumentValueExpression(param.Name, param.Type)};");
-        }
+        // Resolve promise-like params and build args
+        GenerateResolveAndBuildArgs(firstParamName, userParams, requiredParams, optionalParams);
 
         if (returnType == "void")
         {
@@ -2608,6 +2961,26 @@ private void GenerateWrapperMethod(AtsCapabilityInfo capability)
     /// Generates a method on a type class using the thenable pattern.
     /// Generates both an internal async method and a public fluent method.
     /// </summary>
+    /// <remarks>
+    /// <para>Follows the same internal/public pair pattern as <see cref="GenerateBuilderMethod"/>
+    /// but operates on type classes (resources exposed via <c>ExposeMethods</c>).</para>
+    /// <para>Generated TypeScript (example for <c>withEnvironment</c> on <c>PostgresResource</c>):</para>
+    /// <code>
+    /// /** @internal */
+    /// async _withEnvironmentInternal(name: string, value: string): Promise&lt;PostgresResource&gt; {
+    ///     const rpcArgs: Record&lt;string, unknown&gt; = { context: this._handle, name, value };
+    ///     await this._client.invokeCapability&lt;void&gt;('...', rpcArgs);
+    ///     return this;
+    /// }
+    ///
+    /// withEnvironment(name: string, value: string): PostgresResourcePromise {
+    ///     return new PostgresResourcePromiseImpl(
+    ///         this._withEnvironmentInternal(name, value), this._client);
+    /// }
+    /// </code>
+    /// <para>For methods returning a different wrapper type, the internal method returns that
+    /// wrapper and the public method returns its promise class.</para>
+    /// </remarks>
     private void GenerateTypeClassMethod(BuilderModel model, AtsCapabilityInfo capability)
     {
         var className = DeriveClassName(model.TypeId);
@@ -2683,6 +3056,9 @@ private void GenerateTypeClassMethod(BuilderModel model, AtsCapabilityInfo capab
                 GenerateCallbackRegistration(callbackParam);
             }
 
+            // Resolve any promise-like handle parameters
+            GeneratePromiseResolution(userParams);
+
             // Build args with conditional inclusion
             GenerateArgsObjectWithConditionals(targetParamName, requiredParams, optionalParams);
 
@@ -2702,12 +3078,21 @@ private void GenerateTypeClassMethod(BuilderModel model, AtsCapabilityInfo capab
             // Extract optional params and forward
             foreach (var param in optionalParams)
             {
-                WriteLine($"        const {param.Name} = options?.{param.Name};");
+                WriteLine($"        {(IsWidenedHandleType(param.Type) ? "let" : "const")} {param.Name} = options?.{param.Name};");
             }
 
-            Write($"        return new {returnPromiseImplementationClass}(this.{internalMethodName}(");
-            Write(string.Join(", ", userParams.Select(p => p.Name)));
-            WriteLine("));");
+            var internalCall = $"this.{internalMethodName}({string.Join(", ", userParams.Select(p => p.Name))})";
+
+            // For build(), flush pending promises before invoking the internal method to avoid deadlock
+            if (string.Equals(methodName, "build", StringComparison.OrdinalIgnoreCase))
+            {
+                WriteLine($"        const flushAndBuild = async () => {{ await this._client.flushPendingPromises(); return {internalCall}; }};");
+                WriteLine($"        return new {returnPromiseImplementationClass}(flushAndBuild(), this._client, false);");
+            }
+            else
+            {
+                WriteLine($"        return new {returnPromiseImplementationClass}({internalCall}, this._client);");
+            }
             WriteLine("    }");
         }
         else if (isVoid)
@@ -2726,6 +3111,9 @@ private void GenerateTypeClassMethod(BuilderModel model, AtsCapabilityInfo capab
                 GenerateCallbackRegistration(callbackParam);
             }
 
+            // Resolve any promise-like handle parameters
+            GeneratePromiseResolution(userParams);
+
             // Build args with conditional inclusion
             GenerateArgsObjectWithConditionals(targetParamName, requiredParams, optionalParams);
 
@@ -2745,12 +3133,12 @@ private void GenerateTypeClassMethod(BuilderModel model, AtsCapabilityInfo capab
             // Extract optional params and forward
             foreach (var param in optionalParams)
             {
-                WriteLine($"        const {param.Name} = options?.{param.Name};");
+                WriteLine($"        {(IsWidenedHandleType(param.Type) ? "let" : "const")} {param.Name} = options?.{param.Name};");
             }
 
             Write($"        return new {promiseImplementationClass}(this.{internalMethodName}(");
             Write(string.Join(", ", userParams.Select(p => p.Name)));
-            WriteLine("));");
+            WriteLine("), this._client);");
             WriteLine("    }");
         }
         else
@@ -2763,7 +3151,7 @@ private void GenerateTypeClassMethod(BuilderModel model, AtsCapabilityInfo capab
             // Extract optional params from options object
             foreach (var param in optionalParams)
             {
-                WriteLine($"        const {param.Name} = options?.{param.Name};");
+                WriteLine($"        {(IsWidenedHandleType(param.Type) ? "let" : "const")} {param.Name} = options?.{param.Name};");
             }
 
             // Handle callback registration if any
@@ -2773,6 +3161,9 @@ private void GenerateTypeClassMethod(BuilderModel model, AtsCapabilityInfo capab
                 GenerateCallbackRegistration(callbackParam);
             }
 
+            // Resolve any promise-like handle parameters
+            GeneratePromiseResolution(userParams);
+
             // Build args with conditional inclusion
             GenerateArgsObjectWithConditionals(targetParamName, requiredParams, optionalParams);
 
@@ -2799,6 +3190,25 @@ private void GenerateTypeClassMethod(BuilderModel model, AtsCapabilityInfo capab
     /// <summary>
     /// Generates a thenable wrapper class for a type class.
     /// </summary>
+    /// <remarks>
+    /// <para>Identical in structure to <see cref="GenerateThenableClass"/> but generated for
+    /// type classes (resources with <c>ExposeMethods</c>) rather than builder classes.</para>
+    /// <para>Generated TypeScript (example for <c>PostgresResource</c>):</para>
+    /// <code>
+    /// class PostgresResourcePromiseImpl implements PostgresResourcePromise {
+    ///     constructor(private _promise: Promise&lt;PostgresResource&gt;, private _client: AspireClientRpc) {
+    ///         _client.trackPromise(_promise);
+    ///     }
+    ///     then&lt;T1, T2&gt;(...): PromiseLike&lt;T1 | T2&gt; {
+    ///         return this._promise.then(...);
+    ///     }
+    ///     withEnvironment(name: string, value: string): PostgresResourcePromise {
+    ///         return new PostgresResourcePromiseImpl(
+    ///             this._promise.then(obj =&gt; obj.withEnvironment(name, value)), this._client);
+    ///     }
+    /// }
+    /// </code>
+    /// </remarks>
     private void GenerateTypeClassThenableWrapper(BuilderModel model, List<AtsCapabilityInfo> methods)
     {
         var className = DeriveClassName(model.TypeId);
@@ -2809,7 +3219,9 @@ private void GenerateTypeClassThenableWrapper(BuilderModel model, List<AtsCapabi
         WriteLine($" * Thenable wrapper for {className} that enables fluent chaining.");
         WriteLine($" */");
         WriteLine($"class {promiseImplementationClass} implements {promiseClass} {{");
-        WriteLine($"    constructor(private _promise: Promise<{className}>) {{}}");
+        WriteLine($"    constructor(private _promise: Promise<{className}>, private _client: AspireClientRpc, track = true) {{");
+        WriteLine($"        if (track) {{ _client.trackPromise(_promise); }}");
+        WriteLine($"    }}");
         WriteLine();
 
         // Generate then() for PromiseLike interface
@@ -2879,7 +3291,7 @@ private void GenerateTypeClassThenableWrapper(BuilderModel model, List<AtsCapabi
                 WriteLine($"): {returnPromiseWrapper} {{");
                 Write($"        return new {returnPromiseImplementationClass}(this._promise.then(obj => obj.{methodName}(");
                 Write(argsString);
-                WriteLine(")));");
+                WriteLine($")), this._client);");
                 WriteLine("    }");
             }
             else if (isVoid)
@@ -2890,7 +3302,7 @@ private void GenerateTypeClassThenableWrapper(BuilderModel model, List<AtsCapabi
                 WriteLine($"): {promiseClass} {{");
                 Write($"        return new {promiseImplementationClass}(this._promise.then(obj => obj.{methodName}(");
                 Write(argsString);
-                WriteLine(")));");
+                WriteLine($")), this._client);");
                 WriteLine("    }");
             }
             else
diff --git a/src/Aspire.Hosting.CodeGeneration.TypeScript/Resources/base.ts b/src/Aspire.Hosting.CodeGeneration.TypeScript/Resources/base.ts
index 8d7033494fb..219eee04175 100644
--- a/src/Aspire.Hosting.CodeGeneration.TypeScript/Resources/base.ts
+++ b/src/Aspire.Hosting.CodeGeneration.TypeScript/Resources/base.ts
@@ -7,6 +7,12 @@ export { Handle, AspireClient, CapabilityError, CancellationToken, registerCallb
 export type { MarshalledHandle, AtsError, AtsErrorDetails, CallbackFunction } from './transport.js';
 export { AtsErrorCodes, isMarshalledHandle, isAtsError, wrapIfHandle } from './transport.js';
 
+/**
+ * Utility type for parameters that accept either a resolved value or a promise of that value.
+ * Used by generated APIs to allow passing un-awaited resource builders directly.
+ */
+export type Awaitable<T> = T | PromiseLike<T>;
+
 // ============================================================================
 // Reference Expression
 // ============================================================================
diff --git a/src/Aspire.Hosting.CodeGeneration.TypeScript/Resources/transport.ts b/src/Aspire.Hosting.CodeGeneration.TypeScript/Resources/transport.ts
index 9ebab0397fa..4d955e7927d 100644
--- a/src/Aspire.Hosting.CodeGeneration.TypeScript/Resources/transport.ts
+++ b/src/Aspire.Hosting.CodeGeneration.TypeScript/Resources/transport.ts
@@ -14,6 +14,10 @@ export interface AspireClientRpc {
     readonly connected: boolean;
     invokeCapability<TResult = unknown>(capabilityId: string, args?: Record<string, unknown>): Promise<TResult>;
     cancelToken(cancellationId: string): Promise<boolean>;
+    trackPromise(promise: Promise<unknown>): void;
+    flushPendingPromises(): Promise<void>;
+    /** When true (default), rejected tracked promises are collected and re-thrown by flushPendingPromises. */
+    throwOnPendingRejections: boolean;
 }
 
 /**
@@ -385,7 +389,7 @@ export class AppHostUsageError extends Error {
     }
 }
 
-function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
+export function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
     return (
         value !== null &&
         (typeof value === 'object' || typeof value === 'function') &&
@@ -755,9 +759,57 @@ export class AspireClient implements AspireClientRpc {
     private _pendingCalls = 0;
     private _connectPromise: Promise<void> | null = null;
     private _disconnectNotified = false;
+    private _pendingPromises: Set<Promise<unknown>> = new Set();
+    private _rejectedErrors: Set<unknown> = new Set();
+    throwOnPendingRejections = true;
 
     constructor(private socketPath: string) { }
 
+    trackPromise(promise: Promise<unknown>): void {
+        this._pendingPromises.add(promise);
+        // Remove on both resolve and reject. The reject handler swallows the
+        // error to prevent Node.js unhandled-rejection crashes.
+        //
+        // When throwOnPendingRejections is true (default), rejection errors are
+        // eagerly collected so that flushPendingPromises can re-throw them even
+        // if the promise settles before flush is called.
+        //
+        // Limitation: JavaScript provides no way to detect whether a rejection
+        // was already observed by the caller (e.g., try { await p } catch {}).
+        // The .then() reject handler fires regardless. This means user-caught
+        // rejections will also be re-thrown by build(). We accept this tradeoff
+        // because the common case — an un-awaited chain fails silently — should
+        // fail loud. The uncommon case (catch an error from an un-awaited chain,
+        // then continue to build) can opt out with:
+        //   createBuilder({ throwOnPendingRejections: false })
+        promise.then(
+            () => this._pendingPromises.delete(promise),
+            (err) => {
+                this._pendingPromises.delete(promise);
+                if (this.throwOnPendingRejections) {
+                    this._rejectedErrors.add(err);
+                }
+            }
+        );
+    }
+
+    async flushPendingPromises(): Promise<void> {
+        if (this._pendingPromises.size > 0) {
+            console.warn(`Flushing ${this._pendingPromises.size} pending promise(s). Consider awaiting fluent calls to avoid implicit flushing.`);
+            // Snapshot the current set before awaiting. Promises tracked after
+            // flush starts (e.g. by .then() callbacks or the build PromiseImpl
+            // constructor) are excluded. This prevents deadlocks where a tracked
+            // promise depends on flush completing.
+            const pending = [...this._pendingPromises];
+            await Promise.allSettled(pending);
+        }
+        if (this._rejectedErrors.size > 0) {
+            const errors = [...this._rejectedErrors];
+            this._rejectedErrors.clear();
+            throw new AggregateError(errors, 'One or more unawaited fluent calls failed');
+        }
+    }
+
     /**
      * Register a callback to be called when the connection is lost
      */
diff --git a/tests/Aspire.Cli.EndToEnd.Tests/Helpers/CliE2EAutomatorHelpers.cs b/tests/Aspire.Cli.EndToEnd.Tests/Helpers/CliE2EAutomatorHelpers.cs
index 57f388cf504..3b7924884cc 100644
--- a/tests/Aspire.Cli.EndToEnd.Tests/Helpers/CliE2EAutomatorHelpers.cs
+++ b/tests/Aspire.Cli.EndToEnd.Tests/Helpers/CliE2EAutomatorHelpers.cs
@@ -359,6 +359,57 @@ internal static async Task AspireStopAsync(
         await auto.WaitForSuccessPromptAsync(counter);
     }
 
+    /// <summary>
+    /// Asserts that the specified resources exist in the running AppHost by running
+    /// <c>aspire describe &lt;resource&gt; --format json</c> for each expected resource.
+    /// The CLI handles name/displayName resolution internally.
+    /// On failure, the error output from the CLI is visible in the terminal recording.
+    /// </summary>
+    internal static async Task AssertResourcesExistAsync(
+        this Hex1bTerminalAutomator auto,
+        SequenceCounter counter,
+        params string[] expectedResourceNames)
+    {
+        foreach (var resource in expectedResourceNames)
+        {
+            var expectedCounter = counter.Value;
+            await auto.TypeAsync($"aspire describe {resource} --format json");
+            await auto.EnterAsync();
+
+            var succeeded = false;
+            await auto.WaitUntilAsync(s =>
+            {
+                var successSearcher = new CellPatternSearcher()
+                    .FindPattern(expectedCounter.ToString())
+                    .RightText(" OK] $ ");
+                if (successSearcher.Search(s).Count > 0)
+                {
+                    succeeded = true;
+                    return true;
+                }
+
+                var errorSearcher = new CellPatternSearcher()
+                    .FindPattern(expectedCounter.ToString())
+                    .RightText(" ERR:");
+                return errorSearcher.Search(s).Count > 0;
+            }, timeout: TimeSpan.FromSeconds(30), description: $"aspire describe {resource}");
+
+            counter.Increment();
+
+            if (!succeeded)
+            {
+                // Dump all resources so we can see what's actually running
+                await auto.TypeAsync("aspire describe --format json");
+                await auto.EnterAsync();
+                await auto.WaitForAnyPromptAsync(counter);
+
+                throw new InvalidOperationException(
+                    $"Resource '{resource}' not found. 'aspire describe {resource}' exited with an error. " +
+                    "Check the terminal recording for the full resource list above.");
+            }
+        }
+    }
+
     /// <summary>
     /// Copies interesting diagnostic directories from <c>~/.aspire</c> to the mounted workspace
     /// so they are captured by <see cref="CaptureWorkspaceOnFailureAttribute"/>. Call this before
diff --git a/tests/Aspire.Cli.EndToEnd.Tests/TypeScriptCodegenValidationTests.cs b/tests/Aspire.Cli.EndToEnd.Tests/TypeScriptCodegenValidationTests.cs
index df2ee140f7c..e406ca19fa5 100644
--- a/tests/Aspire.Cli.EndToEnd.Tests/TypeScriptCodegenValidationTests.cs
+++ b/tests/Aspire.Cli.EndToEnd.Tests/TypeScriptCodegenValidationTests.cs
@@ -3,7 +3,6 @@
 
 using Aspire.Cli.EndToEnd.Tests.Helpers;
 using Aspire.Cli.Tests.Utils;
-using Aspire.TestUtilities;
 using Hex1b.Automation;
 using Xunit;
 
@@ -98,30 +97,21 @@ public async Task RestoreGeneratesSdkFiles()
     }
 
     [Fact]
-    [QuarantinedTest("https://github.com/microsoft/aspire/issues/15975")]
-    public async Task RunWithMissingAwaitShowsHelpfulError()
+    [CaptureWorkspaceOnFailure]
+    public async Task UnAwaitedChainsCompileWithAutoResolvePromises()
     {
-        using var workspace = TemporaryWorkspace.Create(output);
-
-        var prNumber = CliE2ETestHelpers.GetRequiredPrNumber();
-        var commitSha = CliE2ETestHelpers.GetRequiredCommitSha();
-        var isCI = CliE2ETestHelpers.IsRunningInCI;
+        var repoRoot = CliE2ETestHelpers.GetRepoRoot();
+        var installMode = CliE2ETestHelpers.DetectDockerInstallMode(repoRoot);
+        var workspace = TemporaryWorkspace.Create(output);
 
-        using var terminal = CliE2ETestHelpers.CreateTestTerminal();
+        using var terminal = CliE2ETestHelpers.CreateDockerTestTerminal(repoRoot, installMode, output, mountDockerSocket: true, workspace: workspace);
         var pendingRun = terminal.RunAsync(TestContext.Current.CancellationToken);
 
         var counter = new SequenceCounter();
         var auto = new Hex1bTerminalAutomator(terminal, defaultTimeout: TimeSpan.FromSeconds(500));
 
-        // PrepareEnvironment
-        await auto.PrepareEnvironmentAsync(workspace, counter);
-
-        if (isCI)
-        {
-            await auto.InstallAspireBundleFromPullRequestAsync(prNumber, counter);
-            await auto.SourceAspireBundleEnvironmentAsync(counter);
-            await auto.VerifyAspireCliVersionAsync(commitSha, counter);
-        }
+        await auto.PrepareDockerEnvironmentAsync(counter, workspace);
+        await auto.InstallAspireCliInDockerAsync(installMode, counter);
 
         await auto.TypeAsync("aspire init --language typescript --non-interactive");
         await auto.EnterAsync();
@@ -144,24 +134,47 @@ public async Task RunWithMissingAwaitShowsHelpfulError()
 
             const builder = await createBuilder();
 
+            // None of these are awaited — they return PromiseLike wrappers whose
+            // underlying RPC calls are tracked by trackPromise().
             const postgres = builder.addPostgres("postgres");
             const db = postgres.addDatabase("db");
 
-            await builder.addContainer("consumer", "nginx")
+            // This chain is also NOT awaited. The withReference(db) call accepts
+            // db as a PromiseLike<T> and resolves it internally, but the outer
+            // addContainer().withReference() promise itself stays un-awaited.
+            // This is the key scenario: build() must call flushPendingPromises()
+            // to ensure this chain's RPC calls actually execute.
+            builder.addContainer("consumer", "nginx")
                 .withReference(db);
 
+            // build() flushes all pending promises before proceeding. If the
+            // flush implementation deadlocks (e.g. re-awaiting a promise tracked
+            // after flush starts), this line hangs and the test times out.
             await builder.build().run();
             """;
 
         File.WriteAllText(appHostPath, newContent);
 
-        await auto.TypeAsync("aspire run");
+        // Validate that un-awaited chains compile without type errors.
+        // withReference(db) should accept PromiseLike<T> from the un-awaited addDatabase().
+        await auto.TypeAsync("npx tsc --noEmit");
         await auto.EnterAsync();
-        await auto.WaitUntilAsync(s =>
-            s.ContainsText("❌ AppHost Error:") &&
-            s.ContainsText("Did you forget 'await'"),
-            timeout: TimeSpan.FromMinutes(3), description: "waiting for AppHost error with await hint");
-        await auto.WaitForAnyPromptAsync(counter);
+        await auto.WaitForSuccessPromptFailFastAsync(counter, TimeSpan.FromMinutes(2));
+
+        // Validate runtime behavior: aspire start launches the apphost, which calls
+        // build() and triggers flushPendingPromises(). If the flush deadlocks (e.g. the
+        // build promise is re-awaited in a while loop), the process hangs and this test
+        // times out. A successful start proves un-awaited chains execute their RPC calls.
+        await auto.AspireStartAsync(counter);
+
+        // Verify the un-awaited resources were actually materialized — not silently dropped.
+        // If flushPendingPromises skipped the pending chains, these resources wouldn't exist.
+        await auto.AssertResourcesExistAsync(counter, "postgres", "db", "consumer");
+
+        await auto.AspireStopAsync(counter);
+
+        await auto.CaptureAspireDiagnosticsAsync(counter, workspace);
+
         await auto.TypeAsync("exit");
         await auto.EnterAsync();
 
diff --git a/tests/Aspire.Hosting.CodeGeneration.TypeScript.JsTests/tests/transport.test.ts b/tests/Aspire.Hosting.CodeGeneration.TypeScript.JsTests/tests/transport.test.ts
index 8a157d9ec2c..53b8590f05e 100644
--- a/tests/Aspire.Hosting.CodeGeneration.TypeScript.JsTests/tests/transport.test.ts
+++ b/tests/Aspire.Hosting.CodeGeneration.TypeScript.JsTests/tests/transport.test.ts
@@ -773,3 +773,229 @@ describe('callback invocation protocol', () => {
         }
     });
 });
+
+// ============================================================================
+// Promise Tracking (trackPromise / flushPendingPromises)
+// ============================================================================
+
+describe('trackPromise / flushPendingPromises', () => {
+    function createClient(): AspireClient {
+        return new AspireClient('/dev/null');
+    }
+
+    it('removes promise from pending set on resolve', async () => {
+        const client = createClient();
+        const p = Promise.resolve();
+        client.trackPromise(p);
+        await Promise.resolve();
+        // No pending promises — flush completes immediately
+        await client.flushPendingPromises();
+    });
+
+    it('re-throws pre-flush rejected promise errors by default (throwOnPendingRejections)', async () => {
+        const client = createClient();
+        const p = Promise.reject(new Error('test error'));
+        client.trackPromise(p);
+        await Promise.resolve();
+        // Default: throwOnPendingRejections = true — flush re-throws even pre-settled rejections
+        await expect(client.flushPendingPromises()).rejects.toThrow(AggregateError);
+    });
+
+    it('suppresses pre-flush rejection errors when throwOnPendingRejections is false', async () => {
+        const client = createClient();
+        client.throwOnPendingRejections = false;
+        const p = Promise.reject(new Error('test error'));
+        client.trackPromise(p);
+        await Promise.resolve();
+        // With throwOnPendingRejections = false, pre-flush rejections are silently removed
+        await client.flushPendingPromises();
+    });
+
+    it('resolves immediately when no promises are tracked', async () => {
+        const client = createClient();
+        await client.flushPendingPromises();
+    });
+
+    it('waits for pending promises to resolve', async () => {
+        const client = createClient();
+        let resolved = false;
+        const p = new Promise<void>(resolve => {
+            setTimeout(() => { resolved = true; resolve(); }, 10);
+        });
+        client.trackPromise(p);
+        await client.flushPendingPromises();
+        expect(resolved).toBe(true);
+    });
+
+    it('throws AggregateError when a pending promise rejects during flush', async () => {
+        const client = createClient();
+        const p = new Promise<void>((_, reject) => {
+            setTimeout(() => reject(new Error('boom')), 10);
+        });
+        client.trackPromise(p);
+        await expect(client.flushPendingPromises()).rejects.toThrow(AggregateError);
+    });
+
+    it('collects multiple errors from multiple rejected promises', async () => {
+        const client = createClient();
+        const p1 = new Promise<void>((_, reject) => setTimeout(() => reject(new Error('err1')), 10));
+        const p2 = new Promise<void>((_, reject) => setTimeout(() => reject(new Error('err2')), 10));
+        client.trackPromise(p1);
+        client.trackPromise(p2);
+        try {
+            await client.flushPendingPromises();
+            expect.unreachable('should have thrown');
+        } catch (err) {
+            expect(err).toBeInstanceOf(AggregateError);
+            const msgs = (err as AggregateError).errors.map((e: Error) => e.message).sort();
+            expect(msgs).toEqual(['err1', 'err2']);
+        }
+    });
+
+    it('does not duplicate errors from chained promise wrappers', async () => {
+        // Simulates the generated pattern: inner promise is tracked by
+        // PromiseImpl, then wrapped in .then() which is also tracked by
+        // the chained PromiseImpl. Both adopt the same rejection.
+        const client = createClient();
+
+        const inner = new Promise<string>((_, reject) =>
+            setTimeout(() => reject(new Error('rpc failed')), 10));
+        client.trackPromise(inner);
+
+        // Outer .then() adopts the inner rejection — also tracked
+        const outer = inner.then(val => val);
+        client.trackPromise(outer);
+
+        try {
+            await client.flushPendingPromises();
+            expect.unreachable('should have thrown');
+        } catch (err) {
+            expect(err).toBeInstanceOf(AggregateError);
+            // Should be 1 unique error, not 2 duplicates
+            expect((err as AggregateError).errors.length).toBe(1);
+            expect((err as AggregateError).errors[0].message).toBe('rpc failed');
+        }
+    });
+
+    it('does not poison the client after a failed flush', async () => {
+        // Simulates the build() poisoning scenario: flushPendingPromises throws
+        // AggregateError, the build promise rejects with it, and if tracked,
+        // the reject handler would add the AggregateError back into _rejectedErrors.
+        // A subsequent flush should be clean.
+        const client = createClient();
+
+        const p = new Promise<void>((_, reject) =>
+            setTimeout(() => reject(new Error('chain failed')), 10));
+        client.trackPromise(p);
+
+        // First flush throws
+        await expect(client.flushPendingPromises()).rejects.toThrow(AggregateError);
+
+        // Second flush should be clean — no stale errors
+        await client.flushPendingPromises();
+    });
+
+    it('does not flush promises created by .then() callbacks during flush (known limitation)', async () => {
+        // The snapshot-based flush only awaits promises tracked before flush starts.
+        // Promises tracked by .then() callbacks during flush are excluded to prevent
+        // deadlocks. This is acceptable because the generated fluent API tracks
+        // promises directly (resource.withX()), not via .then() callbacks.
+        const client = createClient();
+
+        let innerResolved = false;
+        const outer = new Promise<string>(resolve =>
+            setTimeout(() => resolve('done'), 10));
+        client.trackPromise(outer);
+
+        outer.then(() => {
+            const inner = new Promise<void>(resolve =>
+                setTimeout(() => { innerResolved = true; resolve(); }, 50));
+            client.trackPromise(inner);
+        });
+
+        await client.flushPendingPromises();
+        expect(innerResolved).toBe(false);
+    });
+
+    it('does not deadlock when build promise depends on flush completing', async () => {
+        // Simulates the build() pattern: the build promise depends on flush
+        // completing but is NOT tracked (build uses track=false in PromiseImpl).
+        const client = createClient();
+
+        let resolveSlowPromise: () => void;
+        const slowPromise = new Promise<void>(resolve => { resolveSlowPromise = resolve; });
+        client.trackPromise(slowPromise);
+
+        const flushPromise = client.flushPendingPromises();
+
+        // Build promise depends on flush but is NOT tracked (mirrors track=false)
+        const buildPromise = new Promise<void>(resolve => {
+            flushPromise.then(() => resolve());
+        });
+
+        resolveSlowPromise!();
+
+        const result = await Promise.race([
+            flushPromise.then(() => 'completed'),
+            new Promise<string>(resolve => setTimeout(() => resolve('deadlocked'), 1000)),
+        ]);
+        expect(result).toBe('completed');
+
+        await buildPromise;
+    });
+
+    it('snapshot excludes promises tracked after flush starts', async () => {
+        // Even if a promise is tracked during flush (e.g. by a PromiseImpl
+        // constructor), the snapshot approach excludes it. This test verifies
+        // that tracking during flush doesn't cause a deadlock.
+        const client = createClient();
+
+        let resolveSlowPromise: () => void;
+        const slowPromise = new Promise<void>(resolve => { resolveSlowPromise = resolve; });
+        client.trackPromise(slowPromise);
+
+        const flushPromise = client.flushPendingPromises();
+
+        // Track a promise during flush — snapshot already taken, won't be awaited
+        const latePromise = new Promise<void>(resolve => {
+            flushPromise.then(() => resolve());
+        });
+        client.trackPromise(latePromise);
+
+        resolveSlowPromise!();
+
+        const result = await Promise.race([
+            flushPromise.then(() => 'completed'),
+            new Promise<string>(resolve => setTimeout(() => resolve('deadlocked'), 1000)),
+        ]);
+        expect(result).toBe('completed');
+
+        await latePromise;
+    });
+
+    it('re-throws user-caught rejections in strict mode (accepted tradeoff)', async () => {
+        // With throwOnPendingRejections (default), even user-caught rejections are
+        // collected and re-thrown. This is the accepted tradeoff: we prefer
+        // failing loud for genuinely un-awaited errors over silently losing them.
+        const client = createClient();
+        const p = Promise.reject(new Error('user handled'));
+        client.trackPromise(p);
+
+        try { await p; } catch { /* handled */ }
+        await Promise.resolve();
+
+        await expect(client.flushPendingPromises()).rejects.toThrow(AggregateError);
+    });
+
+    it('does not re-throw user-caught rejections when throwOnPendingRejections is false', async () => {
+        const client = createClient();
+        client.throwOnPendingRejections = false;
+        const p = Promise.reject(new Error('user handled'));
+        client.trackPromise(p);
+
+        try { await p; } catch { /* handled */ }
+        await Promise.resolve();
+
+        await client.flushPendingPromises();
+    });
+});
diff --git a/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/AtsTypeScriptCodeGeneratorTests.cs b/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/AtsTypeScriptCodeGeneratorTests.cs
index ec2af5d0102..53a7dea12c1 100644
--- a/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/AtsTypeScriptCodeGeneratorTests.cs
+++ b/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/AtsTypeScriptCodeGeneratorTests.cs
@@ -591,7 +591,7 @@ public void Pattern4_InterfaceParameterType_GeneratesUnionType()
         var files = _generator.GenerateDistributedApplication(atsContext);
         var aspireTs = files["aspire.ts"];
 
-        Assert.Contains("withDependency(dependency: ResourceWithConnectionString | TestRedisResource)", aspireTs);
+        Assert.Contains("withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>)", aspireTs);
         Assert.DoesNotContain("withDependency(dependency: HandleReference)", aspireTs);
     }
 
@@ -603,7 +603,7 @@ public void AspireUnion_InterfaceHandleInput_GeneratesExpandedUnion()
         var files = _generator.GenerateDistributedApplication(atsContext);
         var aspireTs = files["aspire.ts"];
 
-        Assert.Contains("withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource)", aspireTs);
+        Assert.Contains("withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>)", aspireTs);
     }
 
     [Fact]
diff --git a/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/Snapshots/AtsGeneratedAspire.verified.ts b/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/Snapshots/AtsGeneratedAspire.verified.ts
index 94667f6a926..e2552700c3f 100644
--- a/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/Snapshots/AtsGeneratedAspire.verified.ts
+++ b/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/Snapshots/AtsGeneratedAspire.verified.ts
@@ -13,7 +13,8 @@ import {
     CapabilityError,
     registerCallback,
     wrapIfHandle,
-    registerHandleWrapper
+    registerHandleWrapper,
+    isPromiseLike
 } from './transport.js';
 import type { AspireClientRpc } from './transport.js';
 
@@ -27,6 +28,8 @@ import {
     AspireList
 } from './base.js';
 
+import type { Awaitable } from './base.js';
+
 // ============================================================================
 // Handle Type Aliases (Internal - not exported to users)
 // ============================================================================
@@ -474,7 +477,7 @@ class TestResourceContextImpl implements TestResourceContext {
     }
 
     setValueAsync(value: string): TestResourceContextPromise {
-        return new TestResourceContextPromiseImpl(this._setValueAsyncInternal(value));
+        return new TestResourceContextPromiseImpl(this._setValueAsyncInternal(value), this._client);
     }
 
     /** Invokes the ValidateAsync method */
@@ -492,7 +495,9 @@ class TestResourceContextImpl implements TestResourceContext {
  * Thenable wrapper for TestResourceContext that enables fluent chaining.
  */
 class TestResourceContextPromiseImpl implements TestResourceContextPromise {
-    constructor(private _promise: Promise<TestResourceContext>) {}
+    constructor(private _promise: Promise<TestResourceContext>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = TestResourceContext, TResult2 = never>(
         onfulfilled?: ((value: TestResourceContext) => TResult1 | PromiseLike<TResult1>) | null,
@@ -508,7 +513,7 @@ class TestResourceContextPromiseImpl implements TestResourceContextPromise {
 
     /** Invokes the SetValueAsync method */
     setValueAsync(value: string): TestResourceContextPromise {
-        return new TestResourceContextPromiseImpl(this._promise.then(obj => obj.setValueAsync(value)));
+        return new TestResourceContextPromiseImpl(this._promise.then(obj => obj.setValueAsync(value)), this._client);
     }
 
     /** Invokes the ValidateAsync method */
@@ -560,7 +565,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
 
     addTestRedis(name: string, options?: AddTestRedisOptions): TestRedisResourcePromise {
         const port = options?.port;
-        return new TestRedisResourcePromiseImpl(this._addTestRedisInternal(name, port));
+        return new TestRedisResourcePromiseImpl(this._addTestRedisInternal(name, port), this._client);
     }
 
     /** Adds a test vault resource */
@@ -575,7 +580,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     }
 
     addTestVault(name: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._addTestVaultInternal(name));
+        return new TestVaultResourcePromiseImpl(this._addTestVaultInternal(name), this._client);
     }
 
 }
@@ -584,7 +589,9 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
  * Thenable wrapper for DistributedApplicationBuilder that enables fluent chaining.
  */
 class DistributedApplicationBuilderPromiseImpl implements DistributedApplicationBuilderPromise {
-    constructor(private _promise: Promise<DistributedApplicationBuilder>) {}
+    constructor(private _promise: Promise<DistributedApplicationBuilder>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = DistributedApplicationBuilder, TResult2 = never>(
         onfulfilled?: ((value: DistributedApplicationBuilder) => TResult1 | PromiseLike<TResult1>) | null,
@@ -595,12 +602,12 @@ class DistributedApplicationBuilderPromiseImpl implements DistributedApplication
 
     /** Adds a test Redis resource */
     addTestRedis(name: string, options?: AddTestRedisOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.addTestRedis(name, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.addTestRedis(name, options)), this._client);
     }
 
     /** Adds a test vault resource */
     addTestVault(name: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.addTestVault(name)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.addTestVault(name)), this._client);
     }
 
 }
@@ -621,9 +628,9 @@ export interface TestDatabaseResource {
     withStatus(status: TestResourceStatus): TestDatabaseResourcePromise;
     withNestedConfig(config: TestNestedDto): TestDatabaseResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestDatabaseResourcePromise;
-    testWaitFor(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise;
-    withDependency(dependency: ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise;
-    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise;
+    testWaitFor(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise;
+    withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise;
+    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise;
     withEndpoints(endpoints: string[]): TestDatabaseResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): TestDatabaseResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestDatabaseResourcePromise;
@@ -649,9 +656,9 @@ export interface TestDatabaseResourcePromise extends PromiseLike<TestDatabaseRes
     withStatus(status: TestResourceStatus): TestDatabaseResourcePromise;
     withNestedConfig(config: TestNestedDto): TestDatabaseResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestDatabaseResourcePromise;
-    testWaitFor(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise;
-    withDependency(dependency: ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise;
-    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise;
+    testWaitFor(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise;
+    withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise;
+    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise;
     withEndpoints(endpoints: string[]): TestDatabaseResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): TestDatabaseResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestDatabaseResourcePromise;
@@ -691,7 +698,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     withOptionalString(options?: WithOptionalStringOptions): TestDatabaseResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new TestDatabaseResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new TestDatabaseResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -706,7 +713,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withConfigInternal(config));
+        return new TestDatabaseResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -726,7 +733,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback));
+        return new TestDatabaseResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -741,7 +748,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new TestDatabaseResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -756,7 +763,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new TestDatabaseResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -771,7 +778,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new TestDatabaseResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -793,7 +800,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): TestDatabaseResourcePromise {
         const callback = options?.callback;
-        return new TestDatabaseResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new TestDatabaseResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -808,7 +815,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withStatusInternal(status));
+        return new TestDatabaseResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -823,7 +830,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new TestDatabaseResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -843,11 +850,12 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new TestDatabaseResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestDatabaseResource> {
+    private async _testWaitForInternal(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestDatabaseResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -857,12 +865,13 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ResourceWithConnectionString | TestRedisResource): Promise<TestDatabaseResource> {
+    private async _withDependencyInternal(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): Promise<TestDatabaseResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -872,12 +881,13 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ResourceWithConnectionString | TestRedisResource): Promise<TestDatabaseResource> {
+    private async _withUnionDependencyInternal(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): Promise<TestDatabaseResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -887,8 +897,8 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -903,7 +913,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new TestDatabaseResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -918,7 +928,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables));
+        return new TestDatabaseResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables), this._client);
     }
 
     /** @internal */
@@ -937,7 +947,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new TestDatabaseResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** @internal */
@@ -954,7 +964,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     /** Adds a data volume */
     withDataVolume(options?: WithDataVolumeOptions): TestDatabaseResourcePromise {
         const name = options?.name;
-        return new TestDatabaseResourcePromiseImpl(this._withDataVolumeInternal(name));
+        return new TestDatabaseResourcePromiseImpl(this._withDataVolumeInternal(name), this._client);
     }
 
     /** @internal */
@@ -969,7 +979,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new TestDatabaseResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -984,7 +994,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new TestDatabaseResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -999,7 +1009,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new TestDatabaseResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -1014,7 +1024,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new TestDatabaseResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -1033,7 +1043,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): TestDatabaseResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new TestDatabaseResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new TestDatabaseResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -1052,7 +1062,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): TestDatabaseResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new TestDatabaseResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new TestDatabaseResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -1067,7 +1077,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new TestDatabaseResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -1082,7 +1092,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new TestDatabaseResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -1093,7 +1103,9 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
  * await builder.addSomething().withX().withY();
  */
 class TestDatabaseResourcePromiseImpl implements TestDatabaseResourcePromise {
-    constructor(private _promise: Promise<TestDatabaseResource>) {}
+    constructor(private _promise: Promise<TestDatabaseResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = TestDatabaseResource, TResult2 = never>(
         onfulfilled?: ((value: TestDatabaseResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -1104,127 +1116,127 @@ class TestDatabaseResourcePromiseImpl implements TestDatabaseResourcePromise {
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)), this._client);
     }
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Adds a data volume */
     withDataVolume(options?: WithDataVolumeOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withDataVolume(options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withDataVolume(options)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -1250,12 +1262,12 @@ export interface TestRedisResource {
     withStatus(status: TestResourceStatus): TestRedisResourcePromise;
     withNestedConfig(config: TestNestedDto): TestRedisResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestRedisResourcePromise;
-    testWaitFor(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise;
+    testWaitFor(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise;
     getEndpoints(): Promise<string[]>;
     withConnectionStringDirect(connectionString: string): TestRedisResourcePromise;
     withRedisSpecific(option: string): TestRedisResourcePromise;
-    withDependency(dependency: ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise;
-    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise;
+    withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise;
+    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise;
     withEndpoints(endpoints: string[]): TestRedisResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): TestRedisResourcePromise;
     getStatusAsync(options?: GetStatusAsyncOptions): Promise<string>;
@@ -1289,12 +1301,12 @@ export interface TestRedisResourcePromise extends PromiseLike<TestRedisResource>
     withStatus(status: TestResourceStatus): TestRedisResourcePromise;
     withNestedConfig(config: TestNestedDto): TestRedisResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestRedisResourcePromise;
-    testWaitFor(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise;
+    testWaitFor(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise;
     getEndpoints(): Promise<string[]>;
     withConnectionStringDirect(connectionString: string): TestRedisResourcePromise;
     withRedisSpecific(option: string): TestRedisResourcePromise;
-    withDependency(dependency: ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise;
-    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise;
+    withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise;
+    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise;
     withEndpoints(endpoints: string[]): TestRedisResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): TestRedisResourcePromise;
     getStatusAsync(options?: GetStatusAsyncOptions): Promise<string>;
@@ -1335,7 +1347,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     /** Adds a child database to a test Redis resource */
     addTestChildDatabase(name: string, options?: AddTestChildDatabaseOptions): TestDatabaseResourcePromise {
         const databaseName = options?.databaseName;
-        return new TestDatabaseResourcePromiseImpl(this._addTestChildDatabaseInternal(name, databaseName));
+        return new TestDatabaseResourcePromiseImpl(this._addTestChildDatabaseInternal(name, databaseName), this._client);
     }
 
     /** @internal */
@@ -1352,7 +1364,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     /** Configures the Redis resource with persistence */
     withPersistence(options?: WithPersistenceOptions): TestRedisResourcePromise {
         const mode = options?.mode;
-        return new TestRedisResourcePromiseImpl(this._withPersistenceInternal(mode));
+        return new TestRedisResourcePromiseImpl(this._withPersistenceInternal(mode), this._client);
     }
 
     /** @internal */
@@ -1371,7 +1383,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     withOptionalString(options?: WithOptionalStringOptions): TestRedisResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new TestRedisResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new TestRedisResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -1386,7 +1398,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withConfigInternal(config));
+        return new TestRedisResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** Gets the tags for the resource */
@@ -1419,7 +1431,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the connection string using a reference expression */
     withConnectionString(connectionString: ReferenceExpression): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withConnectionStringInternal(connectionString));
+        return new TestRedisResourcePromiseImpl(this._withConnectionStringInternal(connectionString), this._client);
     }
 
     /** @internal */
@@ -1439,7 +1451,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback));
+        return new TestRedisResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -1454,7 +1466,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new TestRedisResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -1469,7 +1481,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new TestRedisResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -1484,7 +1496,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new TestRedisResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -1506,7 +1518,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): TestRedisResourcePromise {
         const callback = options?.callback;
-        return new TestRedisResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new TestRedisResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -1521,7 +1533,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withStatusInternal(status));
+        return new TestRedisResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -1536,7 +1548,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new TestRedisResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -1556,11 +1568,12 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new TestRedisResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestRedisResource> {
+    private async _testWaitForInternal(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestRedisResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -1570,8 +1583,8 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** Gets the endpoints */
@@ -1595,7 +1608,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets connection string using direct interface target */
     withConnectionStringDirect(connectionString: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withConnectionStringDirectInternal(connectionString));
+        return new TestRedisResourcePromiseImpl(this._withConnectionStringDirectInternal(connectionString), this._client);
     }
 
     /** @internal */
@@ -1610,11 +1623,12 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Redis-specific configuration */
     withRedisSpecific(option: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withRedisSpecificInternal(option));
+        return new TestRedisResourcePromiseImpl(this._withRedisSpecificInternal(option), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ResourceWithConnectionString | TestRedisResource): Promise<TestRedisResource> {
+    private async _withDependencyInternal(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): Promise<TestRedisResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -1624,12 +1638,13 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ResourceWithConnectionString | TestRedisResource): Promise<TestRedisResource> {
+    private async _withUnionDependencyInternal(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): Promise<TestRedisResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -1639,8 +1654,8 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -1655,7 +1670,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new TestRedisResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -1670,7 +1685,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables));
+        return new TestRedisResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables), this._client);
     }
 
     /** Gets the status of the resource asynchronously */
@@ -1700,7 +1715,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new TestRedisResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** Waits for the resource to be ready */
@@ -1733,7 +1748,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Tests multi-param callback destructuring */
     withMultiParamHandleCallback(callback: (arg1: TestCallbackContext, arg2: TestEnvironmentContext) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withMultiParamHandleCallbackInternal(callback));
+        return new TestRedisResourcePromiseImpl(this._withMultiParamHandleCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -1752,7 +1767,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     withDataVolume(options?: WithDataVolumeOptions): TestRedisResourcePromise {
         const name = options?.name;
         const isReadOnly = options?.isReadOnly;
-        return new TestRedisResourcePromiseImpl(this._withDataVolumeInternal(name, isReadOnly));
+        return new TestRedisResourcePromiseImpl(this._withDataVolumeInternal(name, isReadOnly), this._client);
     }
 
     /** @internal */
@@ -1767,7 +1782,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new TestRedisResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -1782,7 +1797,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new TestRedisResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -1797,7 +1812,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new TestRedisResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -1812,7 +1827,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new TestRedisResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -1831,7 +1846,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): TestRedisResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new TestRedisResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new TestRedisResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -1850,7 +1865,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): TestRedisResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new TestRedisResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new TestRedisResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -1865,7 +1880,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new TestRedisResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -1880,7 +1895,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new TestRedisResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -1891,7 +1906,9 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
  * await builder.addSomething().withX().withY();
  */
 class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
-    constructor(private _promise: Promise<TestRedisResource>) {}
+    constructor(private _promise: Promise<TestRedisResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = TestRedisResource, TResult2 = never>(
         onfulfilled?: ((value: TestRedisResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -1902,22 +1919,22 @@ class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
 
     /** Adds a child database to a test Redis resource */
     addTestChildDatabase(name: string, options?: AddTestChildDatabaseOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.addTestChildDatabase(name, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.addTestChildDatabase(name, options)), this._client);
     }
 
     /** Configures the Redis resource with persistence */
     withPersistence(options?: WithPersistenceOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withPersistence(options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withPersistence(options)), this._client);
     }
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Gets the tags for the resource */
@@ -1932,52 +1949,52 @@ class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
 
     /** Sets the connection string using a reference expression */
     withConnectionString(connectionString: ReferenceExpression): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withConnectionString(connectionString)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withConnectionString(connectionString)), this._client);
     }
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Gets the endpoints */
@@ -1987,32 +2004,32 @@ class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
 
     /** Sets connection string using direct interface target */
     withConnectionStringDirect(connectionString: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withConnectionStringDirect(connectionString)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withConnectionStringDirect(connectionString)), this._client);
     }
 
     /** Redis-specific configuration */
     withRedisSpecific(option: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withRedisSpecific(option)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withRedisSpecific(option)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)), this._client);
     }
 
     /** Gets the status of the resource asynchronously */
@@ -2022,7 +2039,7 @@ class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Waits for the resource to be ready */
@@ -2032,52 +2049,52 @@ class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
 
     /** Tests multi-param callback destructuring */
     withMultiParamHandleCallback(callback: (arg1: TestCallbackContext, arg2: TestEnvironmentContext) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMultiParamHandleCallback(callback)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMultiParamHandleCallback(callback)), this._client);
     }
 
     /** Adds a data volume with persistence */
     withDataVolume(options?: WithDataVolumeOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withDataVolume(options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withDataVolume(options)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -2098,9 +2115,9 @@ export interface TestVaultResource {
     withStatus(status: TestResourceStatus): TestVaultResourcePromise;
     withNestedConfig(config: TestNestedDto): TestVaultResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestVaultResourcePromise;
-    testWaitFor(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise;
-    withDependency(dependency: ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise;
-    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise;
+    testWaitFor(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise;
+    withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise;
+    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise;
     withEndpoints(endpoints: string[]): TestVaultResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): TestVaultResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestVaultResourcePromise;
@@ -2126,9 +2143,9 @@ export interface TestVaultResourcePromise extends PromiseLike<TestVaultResource>
     withStatus(status: TestResourceStatus): TestVaultResourcePromise;
     withNestedConfig(config: TestNestedDto): TestVaultResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestVaultResourcePromise;
-    testWaitFor(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise;
-    withDependency(dependency: ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise;
-    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise;
+    testWaitFor(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise;
+    withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise;
+    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise;
     withEndpoints(endpoints: string[]): TestVaultResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): TestVaultResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestVaultResourcePromise;
@@ -2168,7 +2185,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     withOptionalString(options?: WithOptionalStringOptions): TestVaultResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new TestVaultResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new TestVaultResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -2183,7 +2200,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withConfigInternal(config));
+        return new TestVaultResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -2203,7 +2220,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback));
+        return new TestVaultResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -2218,7 +2235,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new TestVaultResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -2233,7 +2250,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new TestVaultResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -2248,7 +2265,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new TestVaultResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -2270,7 +2287,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): TestVaultResourcePromise {
         const callback = options?.callback;
-        return new TestVaultResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new TestVaultResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -2285,7 +2302,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withStatusInternal(status));
+        return new TestVaultResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -2300,7 +2317,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new TestVaultResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -2320,11 +2337,12 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new TestVaultResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestVaultResource> {
+    private async _testWaitForInternal(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestVaultResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -2334,12 +2352,13 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ResourceWithConnectionString | TestRedisResource): Promise<TestVaultResource> {
+    private async _withDependencyInternal(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): Promise<TestVaultResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -2349,12 +2368,13 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ResourceWithConnectionString | TestRedisResource): Promise<TestVaultResource> {
+    private async _withUnionDependencyInternal(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): Promise<TestVaultResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -2364,8 +2384,8 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -2380,7 +2400,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new TestVaultResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -2395,7 +2415,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables));
+        return new TestVaultResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables), this._client);
     }
 
     /** @internal */
@@ -2414,7 +2434,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new TestVaultResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** @internal */
@@ -2429,7 +2449,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures vault using direct interface target */
     withVaultDirect(option: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withVaultDirectInternal(option));
+        return new TestVaultResourcePromiseImpl(this._withVaultDirectInternal(option), this._client);
     }
 
     /** @internal */
@@ -2444,7 +2464,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new TestVaultResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -2459,7 +2479,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new TestVaultResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -2474,7 +2494,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new TestVaultResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -2489,7 +2509,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new TestVaultResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -2508,7 +2528,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): TestVaultResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new TestVaultResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new TestVaultResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -2527,7 +2547,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): TestVaultResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new TestVaultResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new TestVaultResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -2542,7 +2562,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new TestVaultResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -2557,7 +2577,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new TestVaultResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -2568,7 +2588,9 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
  * await builder.addSomething().withX().withY();
  */
 class TestVaultResourcePromiseImpl implements TestVaultResourcePromise {
-    constructor(private _promise: Promise<TestVaultResource>) {}
+    constructor(private _promise: Promise<TestVaultResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = TestVaultResource, TResult2 = never>(
         onfulfilled?: ((value: TestVaultResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -2579,127 +2601,127 @@ class TestVaultResourcePromiseImpl implements TestVaultResourcePromise {
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)), this._client);
     }
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Configures vault using direct interface target */
     withVaultDirect(option: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withVaultDirect(option)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withVaultDirect(option)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -2719,9 +2741,9 @@ export interface Resource {
     withStatus(status: TestResourceStatus): ResourcePromise;
     withNestedConfig(config: TestNestedDto): ResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ResourcePromise;
-    testWaitFor(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise;
-    withDependency(dependency: ResourceWithConnectionString | TestRedisResource): ResourcePromise;
-    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource): ResourcePromise;
+    testWaitFor(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise;
+    withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): ResourcePromise;
+    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): ResourcePromise;
     withEndpoints(endpoints: string[]): ResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ResourcePromise;
     withMergeLabel(label: string): ResourcePromise;
@@ -2744,9 +2766,9 @@ export interface ResourcePromise extends PromiseLike<Resource> {
     withStatus(status: TestResourceStatus): ResourcePromise;
     withNestedConfig(config: TestNestedDto): ResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ResourcePromise;
-    testWaitFor(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise;
-    withDependency(dependency: ResourceWithConnectionString | TestRedisResource): ResourcePromise;
-    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource): ResourcePromise;
+    testWaitFor(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise;
+    withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): ResourcePromise;
+    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): ResourcePromise;
     withEndpoints(endpoints: string[]): ResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ResourcePromise;
     withMergeLabel(label: string): ResourcePromise;
@@ -2784,7 +2806,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     withOptionalString(options?: WithOptionalStringOptions): ResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new ResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new ResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -2799,7 +2821,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ResourcePromise {
-        return new ResourcePromiseImpl(this._withConfigInternal(config));
+        return new ResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -2814,7 +2836,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new ResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -2829,7 +2851,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new ResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -2844,7 +2866,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new ResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -2866,7 +2888,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ResourcePromise {
         const callback = options?.callback;
-        return new ResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new ResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -2881,7 +2903,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ResourcePromise {
-        return new ResourcePromiseImpl(this._withStatusInternal(status));
+        return new ResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -2896,7 +2918,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ResourcePromise {
-        return new ResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new ResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -2916,11 +2938,12 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ResourcePromise {
-        return new ResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new ResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<Resource> {
+    private async _testWaitForInternal(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<Resource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<IResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -2930,12 +2953,13 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ResourceWithConnectionString | TestRedisResource): Promise<Resource> {
+    private async _withDependencyInternal(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): Promise<Resource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<IResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -2945,12 +2969,13 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ResourceWithConnectionString | TestRedisResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ResourceWithConnectionString | TestRedisResource): Promise<Resource> {
+    private async _withUnionDependencyInternal(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): Promise<Resource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<IResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -2960,8 +2985,8 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -2976,7 +3001,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ResourcePromise {
-        return new ResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new ResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -2995,7 +3020,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new ResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** @internal */
@@ -3010,7 +3035,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new ResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -3025,7 +3050,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new ResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -3040,7 +3065,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ResourcePromise {
-        return new ResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new ResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -3055,7 +3080,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new ResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -3074,7 +3099,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new ResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -3093,7 +3118,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new ResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -3108,7 +3133,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ResourcePromise {
-        return new ResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new ResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -3123,7 +3148,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new ResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -3134,7 +3159,9 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
  * await builder.addSomething().withX().withY();
  */
 class ResourcePromiseImpl implements ResourcePromise {
-    constructor(private _promise: Promise<Resource>) {}
+    constructor(private _promise: Promise<Resource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = Resource, TResult2 = never>(
         onfulfilled?: ((value: Resource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -3145,112 +3172,112 @@ class ResourcePromiseImpl implements ResourcePromise {
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<Resource | ResourceWithConnectionString | ResourceWithEnvironment | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ResourceWithConnectionString | TestRedisResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ResourceWithConnectionString | TestRedisResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ResourceWithConnectionString | TestRedisResource | Awaitable<ResourceWithConnectionString | TestRedisResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -3291,7 +3318,7 @@ class ResourceWithConnectionStringImpl extends ResourceBuilderBase<IResourceWith
 
     /** Sets the connection string using a reference expression */
     withConnectionString(connectionString: ReferenceExpression): ResourceWithConnectionStringPromise {
-        return new ResourceWithConnectionStringPromiseImpl(this._withConnectionStringInternal(connectionString));
+        return new ResourceWithConnectionStringPromiseImpl(this._withConnectionStringInternal(connectionString), this._client);
     }
 
     /** @internal */
@@ -3306,7 +3333,7 @@ class ResourceWithConnectionStringImpl extends ResourceBuilderBase<IResourceWith
 
     /** Sets connection string using direct interface target */
     withConnectionStringDirect(connectionString: string): ResourceWithConnectionStringPromise {
-        return new ResourceWithConnectionStringPromiseImpl(this._withConnectionStringDirectInternal(connectionString));
+        return new ResourceWithConnectionStringPromiseImpl(this._withConnectionStringDirectInternal(connectionString), this._client);
     }
 
 }
@@ -3317,7 +3344,9 @@ class ResourceWithConnectionStringImpl extends ResourceBuilderBase<IResourceWith
  * await builder.addSomething().withX().withY();
  */
 class ResourceWithConnectionStringPromiseImpl implements ResourceWithConnectionStringPromise {
-    constructor(private _promise: Promise<ResourceWithConnectionString>) {}
+    constructor(private _promise: Promise<ResourceWithConnectionString>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ResourceWithConnectionString, TResult2 = never>(
         onfulfilled?: ((value: ResourceWithConnectionString) => TResult1 | PromiseLike<TResult1>) | null,
@@ -3328,12 +3357,12 @@ class ResourceWithConnectionStringPromiseImpl implements ResourceWithConnectionS
 
     /** Sets the connection string using a reference expression */
     withConnectionString(connectionString: ReferenceExpression): ResourceWithConnectionStringPromise {
-        return new ResourceWithConnectionStringPromiseImpl(this._promise.then(obj => obj.withConnectionString(connectionString)));
+        return new ResourceWithConnectionStringPromiseImpl(this._promise.then(obj => obj.withConnectionString(connectionString)), this._client);
     }
 
     /** Sets connection string using direct interface target */
     withConnectionStringDirect(connectionString: string): ResourceWithConnectionStringPromise {
-        return new ResourceWithConnectionStringPromiseImpl(this._promise.then(obj => obj.withConnectionStringDirect(connectionString)));
+        return new ResourceWithConnectionStringPromiseImpl(this._promise.then(obj => obj.withConnectionStringDirect(connectionString)), this._client);
     }
 
 }
@@ -3379,7 +3408,7 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._testWithEnvironmentCallbackInternal(callback));
+        return new ResourceWithEnvironmentPromiseImpl(this._testWithEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -3394,7 +3423,7 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._withEnvironmentVariablesInternal(variables));
+        return new ResourceWithEnvironmentPromiseImpl(this._withEnvironmentVariablesInternal(variables), this._client);
     }
 
 }
@@ -3405,7 +3434,9 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
  * await builder.addSomething().withX().withY();
  */
 class ResourceWithEnvironmentPromiseImpl implements ResourceWithEnvironmentPromise {
-    constructor(private _promise: Promise<ResourceWithEnvironment>) {}
+    constructor(private _promise: Promise<ResourceWithEnvironment>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ResourceWithEnvironment, TResult2 = never>(
         onfulfilled?: ((value: ResourceWithEnvironment) => TResult1 | PromiseLike<TResult1>) | null,
@@ -3416,12 +3447,12 @@ class ResourceWithEnvironmentPromiseImpl implements ResourceWithEnvironmentPromi
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)));
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)), this._client);
     }
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)));
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)), this._client);
     }
 
 }
@@ -3472,6 +3503,11 @@ export async function connect(): Promise<AspireClientRpc> {
 export async function createBuilder(options?: CreateBuilderOptions): Promise<DistributedApplicationBuilder> {
     const client = await connect();
 
+    // Apply client-side options before any tracking begins
+    if (options?.throwOnPendingRejections === false) {
+        client.throwOnPendingRejections = false;
+    }
+
     // Default args, projectDirectory, and appHostFilePath if not provided
     // ASPIRE_APPHOST_FILEPATH is set by the CLI for consistent socket hash computation
     const effectiveOptions: CreateBuilderOptions = {
@@ -3481,6 +3517,9 @@ export async function createBuilder(options?: CreateBuilderOptions): Promise<Dis
         appHostFilePath: options?.appHostFilePath ?? process.env.ASPIRE_APPHOST_FILEPATH
     };
 
+    // Strip client-only options before sending to the host
+    delete effectiveOptions.throwOnPendingRejections;
+
     const handle = await client.invokeCapability<IDistributedApplicationBuilderHandle>(
         'Aspire.Hosting/createBuilderWithOptions',
         { options: effectiveOptions }
@@ -3491,7 +3530,7 @@ export async function createBuilder(options?: CreateBuilderOptions): Promise<Dis
 // Re-export commonly used types
 export { Handle, AppHostUsageError, CancellationToken, CapabilityError, registerCallback } from './transport.js';
 export { refExpr, ReferenceExpression } from './base.js';
-export type { HandleReference } from './base.js';
+export type { HandleReference, Awaitable } from './base.js';
 
 // ============================================================================
 // Global Error Handling
diff --git a/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/Snapshots/TwoPassScanningGeneratedAspire.verified.ts b/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/Snapshots/TwoPassScanningGeneratedAspire.verified.ts
index 2314ee90b47..5421e004b45 100644
--- a/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/Snapshots/TwoPassScanningGeneratedAspire.verified.ts
+++ b/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/Snapshots/TwoPassScanningGeneratedAspire.verified.ts
@@ -13,7 +13,8 @@ import {
     CapabilityError,
     registerCallback,
     wrapIfHandle,
-    registerHandleWrapper
+    registerHandleWrapper,
+    isPromiseLike
 } from './transport.js';
 import type { AspireClientRpc } from './transport.js';
 
@@ -27,6 +28,8 @@ import {
     AspireList
 } from './base.js';
 
+import type { Awaitable } from './base.js';
+
 // ============================================================================
 // Handle Type Aliases (Internal - not exported to users)
 // ============================================================================
@@ -400,6 +403,8 @@ export interface CreateBuilderOptions {
     dashboardApplicationName?: string;
     allowUnsecuredTransport?: boolean;
     enableResourceLogging?: boolean;
+    /** When false, pre-flush rejected promises are not re-thrown by build(). Default: true. */
+    throwOnPendingRejections?: boolean;
 }
 
 /** DTO interface for ExecuteCommandResult */
@@ -464,7 +469,7 @@ export interface AddContainerRegistryFromStringOptions {
 }
 
 export interface AddContainerRegistryOptions {
-    repository?: ParameterResource;
+    repository?: Awaitable<ParameterResource>;
 }
 
 export interface AddDockerfileOptions {
@@ -643,7 +648,7 @@ export interface WithHttpProbeOptions {
 }
 
 export interface WithHttpsDeveloperCertificateOptions {
-    password?: ParameterResource;
+    password?: Awaitable<ParameterResource>;
 }
 
 export interface WithHttpsEndpointOptions {
@@ -885,11 +890,11 @@ export interface CommandLineArgsCallbackContext {
     };
     executionContext: {
         get: () => Promise<DistributedApplicationExecutionContext>;
-        set: (value: DistributedApplicationExecutionContext) => Promise<void>;
+        set: (value: Awaitable<DistributedApplicationExecutionContext>) => Promise<void>;
     };
     logger: {
         get: () => Promise<Logger>;
-        set: (value: Logger) => Promise<void>;
+        set: (value: Awaitable<Logger>) => Promise<void>;
     };
     resource: {
         get: () => Promise<Resource>;
@@ -943,7 +948,8 @@ class CommandLineArgsCallbackContextImpl implements CommandLineArgsCallbackConte
             );
             return new DistributedApplicationExecutionContextImpl(handle, this._client);
         },
-        set: async (value: DistributedApplicationExecutionContext): Promise<void> => {
+        set: async (value: Awaitable<DistributedApplicationExecutionContext>): Promise<void> => {
+            value = isPromiseLike(value) ? await value : value;
             await this._client.invokeCapability<void>(
                 'Aspire.Hosting.ApplicationModel/CommandLineArgsCallbackContext.setExecutionContext',
                 { context: this._handle, value }
@@ -960,7 +966,8 @@ class CommandLineArgsCallbackContextImpl implements CommandLineArgsCallbackConte
             );
             return new LoggerImpl(handle, this._client);
         },
-        set: async (value: Logger): Promise<void> => {
+        set: async (value: Awaitable<Logger>): Promise<void> => {
+            value = isPromiseLike(value) ? await value : value;
             await this._client.invokeCapability<void>(
                 'Aspire.Hosting.ApplicationModel/CommandLineArgsCallbackContext.setLogger',
                 { context: this._handle, value }
@@ -1072,7 +1079,7 @@ class DistributedApplicationImpl implements DistributedApplication {
 
     run(options?: RunOptions): DistributedApplicationPromise {
         const cancellationToken = options?.cancellationToken;
-        return new DistributedApplicationPromiseImpl(this._runInternal(cancellationToken));
+        return new DistributedApplicationPromiseImpl(this._runInternal(cancellationToken), this._client);
     }
 
 }
@@ -1081,7 +1088,9 @@ class DistributedApplicationImpl implements DistributedApplication {
  * Thenable wrapper for DistributedApplication that enables fluent chaining.
  */
 class DistributedApplicationPromiseImpl implements DistributedApplicationPromise {
-    constructor(private _promise: Promise<DistributedApplication>) {}
+    constructor(private _promise: Promise<DistributedApplication>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = DistributedApplication, TResult2 = never>(
         onfulfilled?: ((value: DistributedApplication) => TResult1 | PromiseLike<TResult1>) | null,
@@ -1092,7 +1101,7 @@ class DistributedApplicationPromiseImpl implements DistributedApplicationPromise
 
     /** Runs the distributed application */
     run(options?: RunOptions): DistributedApplicationPromise {
-        return new DistributedApplicationPromiseImpl(this._promise.then(obj => obj.run(options)));
+        return new DistributedApplicationPromiseImpl(this._promise.then(obj => obj.run(options)), this._client);
     }
 
 }
@@ -1242,7 +1251,7 @@ class DistributedApplicationModelImpl implements DistributedApplicationModel {
     }
 
     findResourceByName(name: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._findResourceByNameInternal(name));
+        return new ResourcePromiseImpl(this._findResourceByNameInternal(name), this._client);
     }
 
 }
@@ -1251,7 +1260,9 @@ class DistributedApplicationModelImpl implements DistributedApplicationModel {
  * Thenable wrapper for DistributedApplicationModel that enables fluent chaining.
  */
 class DistributedApplicationModelPromiseImpl implements DistributedApplicationModelPromise {
-    constructor(private _promise: Promise<DistributedApplicationModel>) {}
+    constructor(private _promise: Promise<DistributedApplicationModel>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = DistributedApplicationModel, TResult2 = never>(
         onfulfilled?: ((value: DistributedApplicationModel) => TResult1 | PromiseLike<TResult1>) | null,
@@ -1267,7 +1278,7 @@ class DistributedApplicationModelPromiseImpl implements DistributedApplicationMo
 
     /** Finds a resource by name */
     findResourceByName(name: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.findResourceByName(name)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.findResourceByName(name)), this._client);
     }
 
 }
@@ -1516,7 +1527,9 @@ class EndpointReferenceImpl implements EndpointReference {
  * Thenable wrapper for EndpointReference that enables fluent chaining.
  */
 class EndpointReferencePromiseImpl implements EndpointReferencePromise {
-    constructor(private _promise: Promise<EndpointReference>) {}
+    constructor(private _promise: Promise<EndpointReference>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = EndpointReference, TResult2 = never>(
         onfulfilled?: ((value: EndpointReference) => TResult1 | PromiseLike<TResult1>) | null,
@@ -1612,7 +1625,7 @@ export interface EnvironmentCallbackContext {
     };
     logger: {
         get: () => Promise<Logger>;
-        set: (value: Logger) => Promise<void>;
+        set: (value: Awaitable<Logger>) => Promise<void>;
     };
     resource: {
         get: () => Promise<Resource>;
@@ -1669,7 +1682,8 @@ class EnvironmentCallbackContextImpl implements EnvironmentCallbackContext {
             );
             return new LoggerImpl(handle, this._client);
         },
-        set: async (value: Logger): Promise<void> => {
+        set: async (value: Awaitable<Logger>): Promise<void> => {
+            value = isPromiseLike(value) ? await value : value;
             await this._client.invokeCapability<void>(
                 'Aspire.Hosting.ApplicationModel/EnvironmentCallbackContext.setLogger',
                 { context: this._handle, value }
@@ -1709,7 +1723,7 @@ export interface ExecuteCommandContext {
     toJSON(): MarshalledHandle;
     serviceProvider: {
         get: () => Promise<ServiceProvider>;
-        set: (value: ServiceProvider) => Promise<void>;
+        set: (value: Awaitable<ServiceProvider>) => Promise<void>;
     };
     resourceName: {
         get: () => Promise<string>;
@@ -1721,7 +1735,7 @@ export interface ExecuteCommandContext {
     };
     logger: {
         get: () => Promise<Logger>;
-        set: (value: Logger) => Promise<void>;
+        set: (value: Awaitable<Logger>) => Promise<void>;
     };
 }
 
@@ -1747,7 +1761,8 @@ class ExecuteCommandContextImpl implements ExecuteCommandContext {
             );
             return new ServiceProviderImpl(handle, this._client);
         },
-        set: async (value: ServiceProvider): Promise<void> => {
+        set: async (value: Awaitable<ServiceProvider>): Promise<void> => {
+            value = isPromiseLike(value) ? await value : value;
             await this._client.invokeCapability<void>(
                 'Aspire.Hosting.ApplicationModel/ExecuteCommandContext.setServiceProvider',
                 { context: this._handle, value }
@@ -1797,7 +1812,8 @@ class ExecuteCommandContextImpl implements ExecuteCommandContext {
             );
             return new LoggerImpl(handle, this._client);
         },
-        set: async (value: Logger): Promise<void> => {
+        set: async (value: Awaitable<Logger>): Promise<void> => {
+            value = isPromiseLike(value) ? await value : value;
             await this._client.invokeCapability<void>(
                 'Aspire.Hosting.ApplicationModel/ExecuteCommandContext.setLogger',
                 { context: this._handle, value }
@@ -1908,7 +1924,7 @@ export interface PipelineConfigurationContext {
     toJSON(): MarshalledHandle;
     services: {
         get: () => Promise<ServiceProvider>;
-        set: (value: ServiceProvider) => Promise<void>;
+        set: (value: Awaitable<ServiceProvider>) => Promise<void>;
     };
     steps: {
         get: () => Promise<PipelineStep[]>;
@@ -1916,7 +1932,7 @@ export interface PipelineConfigurationContext {
     };
     model: {
         get: () => Promise<DistributedApplicationModel>;
-        set: (value: DistributedApplicationModel) => Promise<void>;
+        set: (value: Awaitable<DistributedApplicationModel>) => Promise<void>;
     };
     getStepsByTag(tag: string): Promise<PipelineStep[]>;
 }
@@ -1947,7 +1963,8 @@ class PipelineConfigurationContextImpl implements PipelineConfigurationContext {
             );
             return new ServiceProviderImpl(handle, this._client);
         },
-        set: async (value: ServiceProvider): Promise<void> => {
+        set: async (value: Awaitable<ServiceProvider>): Promise<void> => {
+            value = isPromiseLike(value) ? await value : value;
             await this._client.invokeCapability<void>(
                 'Aspire.Hosting.Pipelines/PipelineConfigurationContext.setServices',
                 { context: this._handle, value }
@@ -1980,7 +1997,8 @@ class PipelineConfigurationContextImpl implements PipelineConfigurationContext {
             );
             return new DistributedApplicationModelImpl(handle, this._client);
         },
-        set: async (value: DistributedApplicationModel): Promise<void> => {
+        set: async (value: Awaitable<DistributedApplicationModel>): Promise<void> => {
+            value = isPromiseLike(value) ? await value : value;
             await this._client.invokeCapability<void>(
                 'Aspire.Hosting.Pipelines/PipelineConfigurationContext.setModel',
                 { context: this._handle, value }
@@ -2003,7 +2021,9 @@ class PipelineConfigurationContextImpl implements PipelineConfigurationContext {
  * Thenable wrapper for PipelineConfigurationContext that enables fluent chaining.
  */
 class PipelineConfigurationContextPromiseImpl implements PipelineConfigurationContextPromise {
-    constructor(private _promise: Promise<PipelineConfigurationContext>) {}
+    constructor(private _promise: Promise<PipelineConfigurationContext>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = PipelineConfigurationContext, TResult2 = never>(
         onfulfilled?: ((value: PipelineConfigurationContext) => TResult1 | PromiseLike<TResult1>) | null,
@@ -2152,7 +2172,7 @@ export interface PipelineStep {
     readonly tags: AspireList<string>;
     resource: {
         get: () => Promise<Resource>;
-        set: (value: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource) => Promise<void>;
+        set: (value: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>) => Promise<void>;
     };
     dependsOn(stepName: string): PipelineStepPromise;
     requiredBy(stepName: string): PipelineStepPromise;
@@ -2259,7 +2279,8 @@ class PipelineStepImpl implements PipelineStep {
             );
             return new ResourceImpl(handle, this._client);
         },
-        set: async (value: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<void> => {
+        set: async (value: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<void> => {
+            value = isPromiseLike(value) ? await value : value;
             await this._client.invokeCapability<void>(
                 'Aspire.Hosting.Pipelines/PipelineStep.setResource',
                 { context: this._handle, value }
@@ -2279,7 +2300,7 @@ class PipelineStepImpl implements PipelineStep {
     }
 
     dependsOn(stepName: string): PipelineStepPromise {
-        return new PipelineStepPromiseImpl(this._dependsOnInternal(stepName));
+        return new PipelineStepPromiseImpl(this._dependsOnInternal(stepName), this._client);
     }
 
     /** Specifies that another step requires this step by name */
@@ -2294,7 +2315,7 @@ class PipelineStepImpl implements PipelineStep {
     }
 
     requiredBy(stepName: string): PipelineStepPromise {
-        return new PipelineStepPromiseImpl(this._requiredByInternal(stepName));
+        return new PipelineStepPromiseImpl(this._requiredByInternal(stepName), this._client);
     }
 
 }
@@ -2303,7 +2324,9 @@ class PipelineStepImpl implements PipelineStep {
  * Thenable wrapper for PipelineStep that enables fluent chaining.
  */
 class PipelineStepPromiseImpl implements PipelineStepPromise {
-    constructor(private _promise: Promise<PipelineStep>) {}
+    constructor(private _promise: Promise<PipelineStep>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = PipelineStep, TResult2 = never>(
         onfulfilled?: ((value: PipelineStep) => TResult1 | PromiseLike<TResult1>) | null,
@@ -2314,12 +2337,12 @@ class PipelineStepPromiseImpl implements PipelineStepPromise {
 
     /** Adds a dependency on another step by name */
     dependsOn(stepName: string): PipelineStepPromise {
-        return new PipelineStepPromiseImpl(this._promise.then(obj => obj.dependsOn(stepName)));
+        return new PipelineStepPromiseImpl(this._promise.then(obj => obj.dependsOn(stepName)), this._client);
     }
 
     /** Specifies that another step requires this step by name */
     requiredBy(stepName: string): PipelineStepPromise {
-        return new PipelineStepPromiseImpl(this._promise.then(obj => obj.requiredBy(stepName)));
+        return new PipelineStepPromiseImpl(this._promise.then(obj => obj.requiredBy(stepName)), this._client);
     }
 
 }
@@ -2332,11 +2355,11 @@ export interface PipelineStepContext {
     toJSON(): MarshalledHandle;
     pipelineContext: {
         get: () => Promise<PipelineContext>;
-        set: (value: PipelineContext) => Promise<void>;
+        set: (value: Awaitable<PipelineContext>) => Promise<void>;
     };
     reportingStep: {
         get: () => Promise<ReportingStep>;
-        set: (value: ReportingStep) => Promise<void>;
+        set: (value: Awaitable<ReportingStep>) => Promise<void>;
     };
     model: {
         get: () => Promise<DistributedApplicationModel>;
@@ -2380,7 +2403,8 @@ class PipelineStepContextImpl implements PipelineStepContext {
             );
             return new PipelineContextImpl(handle, this._client);
         },
-        set: async (value: PipelineContext): Promise<void> => {
+        set: async (value: Awaitable<PipelineContext>): Promise<void> => {
+            value = isPromiseLike(value) ? await value : value;
             await this._client.invokeCapability<void>(
                 'Aspire.Hosting.Pipelines/PipelineStepContext.setPipelineContext',
                 { context: this._handle, value }
@@ -2397,7 +2421,8 @@ class PipelineStepContextImpl implements PipelineStepContext {
             );
             return new ReportingStepImpl(handle, this._client);
         },
-        set: async (value: ReportingStep): Promise<void> => {
+        set: async (value: Awaitable<ReportingStep>): Promise<void> => {
+            value = isPromiseLike(value) ? await value : value;
             await this._client.invokeCapability<void>(
                 'Aspire.Hosting.Pipelines/PipelineStepContext.setReportingStep',
                 { context: this._handle, value }
@@ -2481,11 +2506,11 @@ export interface PipelineStepFactoryContext {
     toJSON(): MarshalledHandle;
     pipelineContext: {
         get: () => Promise<PipelineContext>;
-        set: (value: PipelineContext) => Promise<void>;
+        set: (value: Awaitable<PipelineContext>) => Promise<void>;
     };
     resource: {
         get: () => Promise<Resource>;
-        set: (value: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource) => Promise<void>;
+        set: (value: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>) => Promise<void>;
     };
 }
 
@@ -2511,7 +2536,8 @@ class PipelineStepFactoryContextImpl implements PipelineStepFactoryContext {
             );
             return new PipelineContextImpl(handle, this._client);
         },
-        set: async (value: PipelineContext): Promise<void> => {
+        set: async (value: Awaitable<PipelineContext>): Promise<void> => {
+            value = isPromiseLike(value) ? await value : value;
             await this._client.invokeCapability<void>(
                 'Aspire.Hosting.Pipelines/PipelineStepFactoryContext.setPipelineContext',
                 { context: this._handle, value }
@@ -2528,7 +2554,8 @@ class PipelineStepFactoryContextImpl implements PipelineStepFactoryContext {
             );
             return new ResourceImpl(handle, this._client);
         },
-        set: async (value: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<void> => {
+        set: async (value: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<void> => {
+            value = isPromiseLike(value) ? await value : value;
             await this._client.invokeCapability<void>(
                 'Aspire.Hosting.Pipelines/PipelineStepFactoryContext.setResource',
                 { context: this._handle, value }
@@ -2578,7 +2605,7 @@ class PipelineSummaryImpl implements PipelineSummary {
     }
 
     add(key: string, value: string): PipelineSummaryPromise {
-        return new PipelineSummaryPromiseImpl(this._addInternal(key, value));
+        return new PipelineSummaryPromiseImpl(this._addInternal(key, value), this._client);
     }
 
     /** Adds a Markdown-formatted value to the pipeline summary */
@@ -2593,7 +2620,7 @@ class PipelineSummaryImpl implements PipelineSummary {
     }
 
     addMarkdown(key: string, markdownString: string): PipelineSummaryPromise {
-        return new PipelineSummaryPromiseImpl(this._addMarkdownInternal(key, markdownString));
+        return new PipelineSummaryPromiseImpl(this._addMarkdownInternal(key, markdownString), this._client);
     }
 
 }
@@ -2602,7 +2629,9 @@ class PipelineSummaryImpl implements PipelineSummary {
  * Thenable wrapper for PipelineSummary that enables fluent chaining.
  */
 class PipelineSummaryPromiseImpl implements PipelineSummaryPromise {
-    constructor(private _promise: Promise<PipelineSummary>) {}
+    constructor(private _promise: Promise<PipelineSummary>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = PipelineSummary, TResult2 = never>(
         onfulfilled?: ((value: PipelineSummary) => TResult1 | PromiseLike<TResult1>) | null,
@@ -2613,12 +2642,12 @@ class PipelineSummaryPromiseImpl implements PipelineSummaryPromise {
 
     /** Invokes the Add method */
     add(key: string, value: string): PipelineSummaryPromise {
-        return new PipelineSummaryPromiseImpl(this._promise.then(obj => obj.add(key, value)));
+        return new PipelineSummaryPromiseImpl(this._promise.then(obj => obj.add(key, value)), this._client);
     }
 
     /** Adds a Markdown-formatted value to the pipeline summary */
     addMarkdown(key: string, markdownString: string): PipelineSummaryPromise {
-        return new PipelineSummaryPromiseImpl(this._promise.then(obj => obj.addMarkdown(key, markdownString)));
+        return new PipelineSummaryPromiseImpl(this._promise.then(obj => obj.addMarkdown(key, markdownString)), this._client);
     }
 
 }
@@ -2763,7 +2792,7 @@ class ReferenceExpressionBuilderImpl implements ReferenceExpressionBuilder {
     }
 
     appendLiteral(value: string): ReferenceExpressionBuilderPromise {
-        return new ReferenceExpressionBuilderPromiseImpl(this._appendLiteralInternal(value));
+        return new ReferenceExpressionBuilderPromiseImpl(this._appendLiteralInternal(value), this._client);
     }
 
     /** Appends a formatted string value to the reference expression */
@@ -2780,7 +2809,7 @@ class ReferenceExpressionBuilderImpl implements ReferenceExpressionBuilder {
 
     appendFormatted(value: string, options?: AppendFormattedOptions): ReferenceExpressionBuilderPromise {
         const format = options?.format;
-        return new ReferenceExpressionBuilderPromiseImpl(this._appendFormattedInternal(value, format));
+        return new ReferenceExpressionBuilderPromiseImpl(this._appendFormattedInternal(value, format), this._client);
     }
 
     /** Appends a value provider to the reference expression */
@@ -2797,7 +2826,7 @@ class ReferenceExpressionBuilderImpl implements ReferenceExpressionBuilder {
 
     appendValueProvider(valueProvider: any, options?: AppendValueProviderOptions): ReferenceExpressionBuilderPromise {
         const format = options?.format;
-        return new ReferenceExpressionBuilderPromiseImpl(this._appendValueProviderInternal(valueProvider, format));
+        return new ReferenceExpressionBuilderPromiseImpl(this._appendValueProviderInternal(valueProvider, format), this._client);
     }
 
     /** Builds the reference expression */
@@ -2815,7 +2844,9 @@ class ReferenceExpressionBuilderImpl implements ReferenceExpressionBuilder {
  * Thenable wrapper for ReferenceExpressionBuilder that enables fluent chaining.
  */
 class ReferenceExpressionBuilderPromiseImpl implements ReferenceExpressionBuilderPromise {
-    constructor(private _promise: Promise<ReferenceExpressionBuilder>) {}
+    constructor(private _promise: Promise<ReferenceExpressionBuilder>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ReferenceExpressionBuilder, TResult2 = never>(
         onfulfilled?: ((value: ReferenceExpressionBuilder) => TResult1 | PromiseLike<TResult1>) | null,
@@ -2826,17 +2857,17 @@ class ReferenceExpressionBuilderPromiseImpl implements ReferenceExpressionBuilde
 
     /** Appends a literal string to the reference expression */
     appendLiteral(value: string): ReferenceExpressionBuilderPromise {
-        return new ReferenceExpressionBuilderPromiseImpl(this._promise.then(obj => obj.appendLiteral(value)));
+        return new ReferenceExpressionBuilderPromiseImpl(this._promise.then(obj => obj.appendLiteral(value)), this._client);
     }
 
     /** Appends a formatted string value to the reference expression */
     appendFormatted(value: string, options?: AppendFormattedOptions): ReferenceExpressionBuilderPromise {
-        return new ReferenceExpressionBuilderPromiseImpl(this._promise.then(obj => obj.appendFormatted(value, options)));
+        return new ReferenceExpressionBuilderPromiseImpl(this._promise.then(obj => obj.appendFormatted(value, options)), this._client);
     }
 
     /** Appends a value provider to the reference expression */
     appendValueProvider(valueProvider: any, options?: AppendValueProviderOptions): ReferenceExpressionBuilderPromise {
-        return new ReferenceExpressionBuilderPromiseImpl(this._promise.then(obj => obj.appendValueProvider(valueProvider, options)));
+        return new ReferenceExpressionBuilderPromiseImpl(this._promise.then(obj => obj.appendValueProvider(valueProvider, options)), this._client);
     }
 
     /** Builds the reference expression */
@@ -2903,12 +2934,12 @@ class ResourceEndpointsAllocatedEventImpl implements ResourceEndpointsAllocatedE
 
 export interface ResourceLoggerService {
     toJSON(): MarshalledHandle;
-    completeLog(resource: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourceLoggerServicePromise;
+    completeLog(resource: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourceLoggerServicePromise;
     completeLogByName(resourceName: string): ResourceLoggerServicePromise;
 }
 
 export interface ResourceLoggerServicePromise extends PromiseLike<ResourceLoggerService> {
-    completeLog(resource: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourceLoggerServicePromise;
+    completeLog(resource: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourceLoggerServicePromise;
     completeLogByName(resourceName: string): ResourceLoggerServicePromise;
 }
 
@@ -2927,7 +2958,8 @@ class ResourceLoggerServiceImpl implements ResourceLoggerService {
 
     /** Completes the log stream for a resource */
     /** @internal */
-    async _completeLogInternal(resource: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ResourceLoggerService> {
+    async _completeLogInternal(resource: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ResourceLoggerService> {
+        resource = isPromiseLike(resource) ? await resource : resource;
         const rpcArgs: Record<string, unknown> = { loggerService: this._handle, resource };
         await this._client.invokeCapability<void>(
             'Aspire.Hosting/completeLog',
@@ -2936,8 +2968,8 @@ class ResourceLoggerServiceImpl implements ResourceLoggerService {
         return this;
     }
 
-    completeLog(resource: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourceLoggerServicePromise {
-        return new ResourceLoggerServicePromiseImpl(this._completeLogInternal(resource));
+    completeLog(resource: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourceLoggerServicePromise {
+        return new ResourceLoggerServicePromiseImpl(this._completeLogInternal(resource), this._client);
     }
 
     /** Completes the log stream by resource name */
@@ -2952,7 +2984,7 @@ class ResourceLoggerServiceImpl implements ResourceLoggerService {
     }
 
     completeLogByName(resourceName: string): ResourceLoggerServicePromise {
-        return new ResourceLoggerServicePromiseImpl(this._completeLogByNameInternal(resourceName));
+        return new ResourceLoggerServicePromiseImpl(this._completeLogByNameInternal(resourceName), this._client);
     }
 
 }
@@ -2961,7 +2993,9 @@ class ResourceLoggerServiceImpl implements ResourceLoggerService {
  * Thenable wrapper for ResourceLoggerService that enables fluent chaining.
  */
 class ResourceLoggerServicePromiseImpl implements ResourceLoggerServicePromise {
-    constructor(private _promise: Promise<ResourceLoggerService>) {}
+    constructor(private _promise: Promise<ResourceLoggerService>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ResourceLoggerService, TResult2 = never>(
         onfulfilled?: ((value: ResourceLoggerService) => TResult1 | PromiseLike<TResult1>) | null,
@@ -2971,13 +3005,13 @@ class ResourceLoggerServicePromiseImpl implements ResourceLoggerServicePromise {
     }
 
     /** Completes the log stream for a resource */
-    completeLog(resource: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourceLoggerServicePromise {
-        return new ResourceLoggerServicePromiseImpl(this._promise.then(obj => obj.completeLog(resource)));
+    completeLog(resource: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourceLoggerServicePromise {
+        return new ResourceLoggerServicePromiseImpl(this._promise.then(obj => obj.completeLog(resource)), this._client);
     }
 
     /** Completes the log stream by resource name */
     completeLogByName(resourceName: string): ResourceLoggerServicePromise {
-        return new ResourceLoggerServicePromiseImpl(this._promise.then(obj => obj.completeLogByName(resourceName)));
+        return new ResourceLoggerServicePromiseImpl(this._promise.then(obj => obj.completeLogByName(resourceName)), this._client);
     }
 
 }
@@ -2991,18 +3025,18 @@ export interface ResourceNotificationService {
     waitForResourceState(resourceName: string, options?: WaitForResourceStateOptions): ResourceNotificationServicePromise;
     waitForResourceStates(resourceName: string, targetStates: string[]): Promise<string>;
     waitForResourceHealthy(resourceName: string): Promise<ResourceEventDto>;
-    waitForDependencies(resource: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourceNotificationServicePromise;
+    waitForDependencies(resource: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourceNotificationServicePromise;
     tryGetResourceState(resourceName: string): Promise<ResourceEventDto>;
-    publishResourceUpdate(resource: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: PublishResourceUpdateOptions): ResourceNotificationServicePromise;
+    publishResourceUpdate(resource: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: PublishResourceUpdateOptions): ResourceNotificationServicePromise;
 }
 
 export interface ResourceNotificationServicePromise extends PromiseLike<ResourceNotificationService> {
     waitForResourceState(resourceName: string, options?: WaitForResourceStateOptions): ResourceNotificationServicePromise;
     waitForResourceStates(resourceName: string, targetStates: string[]): Promise<string>;
     waitForResourceHealthy(resourceName: string): Promise<ResourceEventDto>;
-    waitForDependencies(resource: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourceNotificationServicePromise;
+    waitForDependencies(resource: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourceNotificationServicePromise;
     tryGetResourceState(resourceName: string): Promise<ResourceEventDto>;
-    publishResourceUpdate(resource: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: PublishResourceUpdateOptions): ResourceNotificationServicePromise;
+    publishResourceUpdate(resource: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: PublishResourceUpdateOptions): ResourceNotificationServicePromise;
 }
 
 // ============================================================================
@@ -3032,7 +3066,7 @@ class ResourceNotificationServiceImpl implements ResourceNotificationService {
 
     waitForResourceState(resourceName: string, options?: WaitForResourceStateOptions): ResourceNotificationServicePromise {
         const targetState = options?.targetState;
-        return new ResourceNotificationServicePromiseImpl(this._waitForResourceStateInternal(resourceName, targetState));
+        return new ResourceNotificationServicePromiseImpl(this._waitForResourceStateInternal(resourceName, targetState), this._client);
     }
 
     /** Waits for a resource to reach one of the specified states */
@@ -3055,7 +3089,8 @@ class ResourceNotificationServiceImpl implements ResourceNotificationService {
 
     /** Waits for all dependencies of a resource to be ready */
     /** @internal */
-    async _waitForDependenciesInternal(resource: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ResourceNotificationService> {
+    async _waitForDependenciesInternal(resource: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ResourceNotificationService> {
+        resource = isPromiseLike(resource) ? await resource : resource;
         const rpcArgs: Record<string, unknown> = { notificationService: this._handle, resource };
         await this._client.invokeCapability<void>(
             'Aspire.Hosting/waitForDependencies',
@@ -3064,8 +3099,8 @@ class ResourceNotificationServiceImpl implements ResourceNotificationService {
         return this;
     }
 
-    waitForDependencies(resource: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourceNotificationServicePromise {
-        return new ResourceNotificationServicePromiseImpl(this._waitForDependenciesInternal(resource));
+    waitForDependencies(resource: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourceNotificationServicePromise {
+        return new ResourceNotificationServicePromiseImpl(this._waitForDependenciesInternal(resource), this._client);
     }
 
     /** Tries to get the current state of a resource */
@@ -3079,7 +3114,8 @@ class ResourceNotificationServiceImpl implements ResourceNotificationService {
 
     /** Publishes an update for a resource's state */
     /** @internal */
-    async _publishResourceUpdateInternal(resource: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, state?: string, stateStyle?: string): Promise<ResourceNotificationService> {
+    async _publishResourceUpdateInternal(resource: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, state?: string, stateStyle?: string): Promise<ResourceNotificationService> {
+        resource = isPromiseLike(resource) ? await resource : resource;
         const rpcArgs: Record<string, unknown> = { notificationService: this._handle, resource };
         if (state !== undefined) rpcArgs.state = state;
         if (stateStyle !== undefined) rpcArgs.stateStyle = stateStyle;
@@ -3090,10 +3126,10 @@ class ResourceNotificationServiceImpl implements ResourceNotificationService {
         return this;
     }
 
-    publishResourceUpdate(resource: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: PublishResourceUpdateOptions): ResourceNotificationServicePromise {
+    publishResourceUpdate(resource: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: PublishResourceUpdateOptions): ResourceNotificationServicePromise {
         const state = options?.state;
         const stateStyle = options?.stateStyle;
-        return new ResourceNotificationServicePromiseImpl(this._publishResourceUpdateInternal(resource, state, stateStyle));
+        return new ResourceNotificationServicePromiseImpl(this._publishResourceUpdateInternal(resource, state, stateStyle), this._client);
     }
 
 }
@@ -3102,7 +3138,9 @@ class ResourceNotificationServiceImpl implements ResourceNotificationService {
  * Thenable wrapper for ResourceNotificationService that enables fluent chaining.
  */
 class ResourceNotificationServicePromiseImpl implements ResourceNotificationServicePromise {
-    constructor(private _promise: Promise<ResourceNotificationService>) {}
+    constructor(private _promise: Promise<ResourceNotificationService>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ResourceNotificationService, TResult2 = never>(
         onfulfilled?: ((value: ResourceNotificationService) => TResult1 | PromiseLike<TResult1>) | null,
@@ -3113,7 +3151,7 @@ class ResourceNotificationServicePromiseImpl implements ResourceNotificationServ
 
     /** Waits for a resource to reach a specified state */
     waitForResourceState(resourceName: string, options?: WaitForResourceStateOptions): ResourceNotificationServicePromise {
-        return new ResourceNotificationServicePromiseImpl(this._promise.then(obj => obj.waitForResourceState(resourceName, options)));
+        return new ResourceNotificationServicePromiseImpl(this._promise.then(obj => obj.waitForResourceState(resourceName, options)), this._client);
     }
 
     /** Waits for a resource to reach one of the specified states */
@@ -3127,8 +3165,8 @@ class ResourceNotificationServicePromiseImpl implements ResourceNotificationServ
     }
 
     /** Waits for all dependencies of a resource to be ready */
-    waitForDependencies(resource: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourceNotificationServicePromise {
-        return new ResourceNotificationServicePromiseImpl(this._promise.then(obj => obj.waitForDependencies(resource)));
+    waitForDependencies(resource: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourceNotificationServicePromise {
+        return new ResourceNotificationServicePromiseImpl(this._promise.then(obj => obj.waitForDependencies(resource)), this._client);
     }
 
     /** Tries to get the current state of a resource */
@@ -3137,8 +3175,8 @@ class ResourceNotificationServicePromiseImpl implements ResourceNotificationServ
     }
 
     /** Publishes an update for a resource's state */
-    publishResourceUpdate(resource: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: PublishResourceUpdateOptions): ResourceNotificationServicePromise {
-        return new ResourceNotificationServicePromiseImpl(this._promise.then(obj => obj.publishResourceUpdate(resource, options)));
+    publishResourceUpdate(resource: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: PublishResourceUpdateOptions): ResourceNotificationServicePromise {
+        return new ResourceNotificationServicePromiseImpl(this._promise.then(obj => obj.publishResourceUpdate(resource, options)), this._client);
     }
 
 }
@@ -3260,7 +3298,7 @@ export interface ResourceUrlsCallbackContext {
     };
     logger: {
         get: () => Promise<Logger>;
-        set: (value: Logger) => Promise<void>;
+        set: (value: Awaitable<Logger>) => Promise<void>;
     };
     executionContext: {
         get: () => Promise<DistributedApplicationExecutionContext>;
@@ -3325,7 +3363,8 @@ class ResourceUrlsCallbackContextImpl implements ResourceUrlsCallbackContext {
             );
             return new LoggerImpl(handle, this._client);
         },
-        set: async (value: Logger): Promise<void> => {
+        set: async (value: Awaitable<Logger>): Promise<void> => {
+            value = isPromiseLike(value) ? await value : value;
             await this._client.invokeCapability<void>(
                 'Aspire.Hosting.ApplicationModel/ResourceUrlsCallbackContext.setLogger',
                 { context: this._handle, value }
@@ -3657,7 +3696,7 @@ class TestResourceContextImpl implements TestResourceContext {
     }
 
     setValueAsync(value: string): TestResourceContextPromise {
-        return new TestResourceContextPromiseImpl(this._setValueAsyncInternal(value));
+        return new TestResourceContextPromiseImpl(this._setValueAsyncInternal(value), this._client);
     }
 
     /** Invokes the ValidateAsync method */
@@ -3675,7 +3714,9 @@ class TestResourceContextImpl implements TestResourceContext {
  * Thenable wrapper for TestResourceContext that enables fluent chaining.
  */
 class TestResourceContextPromiseImpl implements TestResourceContextPromise {
-    constructor(private _promise: Promise<TestResourceContext>) {}
+    constructor(private _promise: Promise<TestResourceContext>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = TestResourceContext, TResult2 = never>(
         onfulfilled?: ((value: TestResourceContext) => TResult1 | PromiseLike<TResult1>) | null,
@@ -3691,7 +3732,7 @@ class TestResourceContextPromiseImpl implements TestResourceContextPromise {
 
     /** Invokes the SetValueAsync method */
     setValueAsync(value: string): TestResourceContextPromise {
-        return new TestResourceContextPromiseImpl(this._promise.then(obj => obj.setValueAsync(value)));
+        return new TestResourceContextPromiseImpl(this._promise.then(obj => obj.setValueAsync(value)), this._client);
     }
 
     /** Invokes the ValidateAsync method */
@@ -3709,7 +3750,7 @@ export interface UpdateCommandStateContext {
     toJSON(): MarshalledHandle;
     serviceProvider: {
         get: () => Promise<ServiceProvider>;
-        set: (value: ServiceProvider) => Promise<void>;
+        set: (value: Awaitable<ServiceProvider>) => Promise<void>;
     };
 }
 
@@ -3735,7 +3776,8 @@ class UpdateCommandStateContextImpl implements UpdateCommandStateContext {
             );
             return new ServiceProviderImpl(handle, this._client);
         },
-        set: async (value: ServiceProvider): Promise<void> => {
+        set: async (value: Awaitable<ServiceProvider>): Promise<void> => {
+            value = isPromiseLike(value) ? await value : value;
             await this._client.invokeCapability<void>(
                 'Aspire.Hosting.ApplicationModel/UpdateCommandStateContext.setServiceProvider',
                 { context: this._handle, value }
@@ -3830,7 +3872,9 @@ class ConfigurationImpl implements Configuration {
  * Thenable wrapper for Configuration that enables fluent chaining.
  */
 class ConfigurationPromiseImpl implements ConfigurationPromise {
-    constructor(private _promise: Promise<Configuration>) {}
+    constructor(private _promise: Promise<Configuration>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = Configuration, TResult2 = never>(
         onfulfilled?: ((value: Configuration) => TResult1 | PromiseLike<TResult1>) | null,
@@ -3890,7 +3934,7 @@ export interface DistributedApplicationBuilder {
     build(): DistributedApplicationPromise;
     addConnectionStringExpression(name: string, connectionStringExpression: ReferenceExpression): ConnectionStringResourcePromise;
     addConnectionStringBuilder(name: string, connectionStringBuilder: (obj: ReferenceExpressionBuilder) => Promise<void>): ConnectionStringResourcePromise;
-    addContainerRegistry(name: string, endpoint: ParameterResource, options?: AddContainerRegistryOptions): ContainerRegistryResourcePromise;
+    addContainerRegistry(name: string, endpoint: Awaitable<ParameterResource>, options?: AddContainerRegistryOptions): ContainerRegistryResourcePromise;
     addContainerRegistryFromString(name: string, endpoint: string, options?: AddContainerRegistryFromStringOptions): ContainerRegistryResourcePromise;
     addContainer(name: string, image: string): ContainerResourcePromise;
     addDockerfile(name: string, contextPath: string, options?: AddDockerfileOptions): ContainerResourcePromise;
@@ -3898,7 +3942,7 @@ export interface DistributedApplicationBuilder {
     addExecutable(name: string, command: string, workingDirectory: string, args: string[]): ExecutableResourcePromise;
     addExternalService(name: string, url: string): ExternalServiceResourcePromise;
     addExternalServiceUri(name: string, uri: string): ExternalServiceResourcePromise;
-    addExternalServiceParameter(name: string, urlParameter: ParameterResource): ExternalServiceResourcePromise;
+    addExternalServiceParameter(name: string, urlParameter: Awaitable<ParameterResource>): ExternalServiceResourcePromise;
     addParameter(name: string, options?: AddParameterOptions): ParameterResourcePromise;
     addParameterWithValue(name: string, value: string, options?: AddParameterWithValueOptions): ParameterResourcePromise;
     addParameterFromConfiguration(name: string, configurationKey: string, options?: AddParameterFromConfigurationOptions): ParameterResourcePromise;
@@ -3918,7 +3962,7 @@ export interface DistributedApplicationBuilderPromise extends PromiseLike<Distri
     build(): DistributedApplicationPromise;
     addConnectionStringExpression(name: string, connectionStringExpression: ReferenceExpression): ConnectionStringResourcePromise;
     addConnectionStringBuilder(name: string, connectionStringBuilder: (obj: ReferenceExpressionBuilder) => Promise<void>): ConnectionStringResourcePromise;
-    addContainerRegistry(name: string, endpoint: ParameterResource, options?: AddContainerRegistryOptions): ContainerRegistryResourcePromise;
+    addContainerRegistry(name: string, endpoint: Awaitable<ParameterResource>, options?: AddContainerRegistryOptions): ContainerRegistryResourcePromise;
     addContainerRegistryFromString(name: string, endpoint: string, options?: AddContainerRegistryFromStringOptions): ContainerRegistryResourcePromise;
     addContainer(name: string, image: string): ContainerResourcePromise;
     addDockerfile(name: string, contextPath: string, options?: AddDockerfileOptions): ContainerResourcePromise;
@@ -3926,7 +3970,7 @@ export interface DistributedApplicationBuilderPromise extends PromiseLike<Distri
     addExecutable(name: string, command: string, workingDirectory: string, args: string[]): ExecutableResourcePromise;
     addExternalService(name: string, url: string): ExternalServiceResourcePromise;
     addExternalServiceUri(name: string, uri: string): ExternalServiceResourcePromise;
-    addExternalServiceParameter(name: string, urlParameter: ParameterResource): ExternalServiceResourcePromise;
+    addExternalServiceParameter(name: string, urlParameter: Awaitable<ParameterResource>): ExternalServiceResourcePromise;
     addParameter(name: string, options?: AddParameterOptions): ParameterResourcePromise;
     addParameterWithValue(name: string, value: string, options?: AddParameterWithValueOptions): ParameterResourcePromise;
     addParameterFromConfiguration(name: string, configurationKey: string, options?: AddParameterFromConfigurationOptions): ParameterResourcePromise;
@@ -4021,7 +4065,8 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     }
 
     build(): DistributedApplicationPromise {
-        return new DistributedApplicationPromiseImpl(this._buildInternal());
+        const flushAndBuild = async () => { await this._client.flushPendingPromises(); return this._buildInternal(); };
+        return new DistributedApplicationPromiseImpl(flushAndBuild(), this._client, false);
     }
 
     /** Adds a connection string with a reference expression */
@@ -4036,7 +4081,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     }
 
     addConnectionStringExpression(name: string, connectionStringExpression: ReferenceExpression): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._addConnectionStringExpressionInternal(name, connectionStringExpression));
+        return new ConnectionStringResourcePromiseImpl(this._addConnectionStringExpressionInternal(name, connectionStringExpression), this._client);
     }
 
     /** Adds a connection string with a builder callback */
@@ -4056,12 +4101,14 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     }
 
     addConnectionStringBuilder(name: string, connectionStringBuilder: (obj: ReferenceExpressionBuilder) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._addConnectionStringBuilderInternal(name, connectionStringBuilder));
+        return new ConnectionStringResourcePromiseImpl(this._addConnectionStringBuilderInternal(name, connectionStringBuilder), this._client);
     }
 
     /** Adds a container registry resource */
     /** @internal */
-    async _addContainerRegistryInternal(name: string, endpoint: ParameterResource, repository?: ParameterResource): Promise<ContainerRegistryResource> {
+    async _addContainerRegistryInternal(name: string, endpoint: Awaitable<ParameterResource>, repository?: Awaitable<ParameterResource>): Promise<ContainerRegistryResource> {
+        endpoint = isPromiseLike(endpoint) ? await endpoint : endpoint;
+        repository = isPromiseLike(repository) ? await repository : repository;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, endpoint };
         if (repository !== undefined) rpcArgs.repository = repository;
         const result = await this._client.invokeCapability<ContainerRegistryResourceHandle>(
@@ -4071,9 +4118,9 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
         return new ContainerRegistryResourceImpl(result, this._client);
     }
 
-    addContainerRegistry(name: string, endpoint: ParameterResource, options?: AddContainerRegistryOptions): ContainerRegistryResourcePromise {
-        const repository = options?.repository;
-        return new ContainerRegistryResourcePromiseImpl(this._addContainerRegistryInternal(name, endpoint, repository));
+    addContainerRegistry(name: string, endpoint: Awaitable<ParameterResource>, options?: AddContainerRegistryOptions): ContainerRegistryResourcePromise {
+        let repository = options?.repository;
+        return new ContainerRegistryResourcePromiseImpl(this._addContainerRegistryInternal(name, endpoint, repository), this._client);
     }
 
     /** Adds a container registry with string endpoint */
@@ -4090,7 +4137,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
 
     addContainerRegistryFromString(name: string, endpoint: string, options?: AddContainerRegistryFromStringOptions): ContainerRegistryResourcePromise {
         const repository = options?.repository;
-        return new ContainerRegistryResourcePromiseImpl(this._addContainerRegistryFromStringInternal(name, endpoint, repository));
+        return new ContainerRegistryResourcePromiseImpl(this._addContainerRegistryFromStringInternal(name, endpoint, repository), this._client);
     }
 
     /** Adds a container resource */
@@ -4105,7 +4152,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     }
 
     addContainer(name: string, image: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._addContainerInternal(name, image));
+        return new ContainerResourcePromiseImpl(this._addContainerInternal(name, image), this._client);
     }
 
     /** Adds a container resource built from a Dockerfile */
@@ -4124,7 +4171,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     addDockerfile(name: string, contextPath: string, options?: AddDockerfileOptions): ContainerResourcePromise {
         const dockerfilePath = options?.dockerfilePath;
         const stage = options?.stage;
-        return new ContainerResourcePromiseImpl(this._addDockerfileInternal(name, contextPath, dockerfilePath, stage));
+        return new ContainerResourcePromiseImpl(this._addDockerfileInternal(name, contextPath, dockerfilePath, stage), this._client);
     }
 
     /** Adds a .NET tool resource */
@@ -4139,7 +4186,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     }
 
     addDotnetTool(name: string, packageId: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._addDotnetToolInternal(name, packageId));
+        return new DotnetToolResourcePromiseImpl(this._addDotnetToolInternal(name, packageId), this._client);
     }
 
     /** Adds an executable resource */
@@ -4154,7 +4201,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     }
 
     addExecutable(name: string, command: string, workingDirectory: string, args: string[]): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._addExecutableInternal(name, command, workingDirectory, args));
+        return new ExecutableResourcePromiseImpl(this._addExecutableInternal(name, command, workingDirectory, args), this._client);
     }
 
     /** Adds an external service resource */
@@ -4169,7 +4216,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     }
 
     addExternalService(name: string, url: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._addExternalServiceInternal(name, url));
+        return new ExternalServiceResourcePromiseImpl(this._addExternalServiceInternal(name, url), this._client);
     }
 
     /** Adds an external service with a URI */
@@ -4184,12 +4231,13 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     }
 
     addExternalServiceUri(name: string, uri: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._addExternalServiceUriInternal(name, uri));
+        return new ExternalServiceResourcePromiseImpl(this._addExternalServiceUriInternal(name, uri), this._client);
     }
 
     /** Adds an external service with a parameter URL */
     /** @internal */
-    async _addExternalServiceParameterInternal(name: string, urlParameter: ParameterResource): Promise<ExternalServiceResource> {
+    async _addExternalServiceParameterInternal(name: string, urlParameter: Awaitable<ParameterResource>): Promise<ExternalServiceResource> {
+        urlParameter = isPromiseLike(urlParameter) ? await urlParameter : urlParameter;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, urlParameter };
         const result = await this._client.invokeCapability<ExternalServiceResourceHandle>(
             'Aspire.Hosting/addExternalServiceParameter',
@@ -4198,8 +4246,8 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
         return new ExternalServiceResourceImpl(result, this._client);
     }
 
-    addExternalServiceParameter(name: string, urlParameter: ParameterResource): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._addExternalServiceParameterInternal(name, urlParameter));
+    addExternalServiceParameter(name: string, urlParameter: Awaitable<ParameterResource>): ExternalServiceResourcePromise {
+        return new ExternalServiceResourcePromiseImpl(this._addExternalServiceParameterInternal(name, urlParameter), this._client);
     }
 
     /** Adds a parameter resource */
@@ -4216,7 +4264,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
 
     addParameter(name: string, options?: AddParameterOptions): ParameterResourcePromise {
         const secret = options?.secret;
-        return new ParameterResourcePromiseImpl(this._addParameterInternal(name, secret));
+        return new ParameterResourcePromiseImpl(this._addParameterInternal(name, secret), this._client);
     }
 
     /** Adds a parameter with a default value */
@@ -4235,7 +4283,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     addParameterWithValue(name: string, value: string, options?: AddParameterWithValueOptions): ParameterResourcePromise {
         const publishValueAsDefault = options?.publishValueAsDefault;
         const secret = options?.secret;
-        return new ParameterResourcePromiseImpl(this._addParameterWithValueInternal(name, value, publishValueAsDefault, secret));
+        return new ParameterResourcePromiseImpl(this._addParameterWithValueInternal(name, value, publishValueAsDefault, secret), this._client);
     }
 
     /** Adds a parameter sourced from configuration */
@@ -4252,7 +4300,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
 
     addParameterFromConfiguration(name: string, configurationKey: string, options?: AddParameterFromConfigurationOptions): ParameterResourcePromise {
         const secret = options?.secret;
-        return new ParameterResourcePromiseImpl(this._addParameterFromConfigurationInternal(name, configurationKey, secret));
+        return new ParameterResourcePromiseImpl(this._addParameterFromConfigurationInternal(name, configurationKey, secret), this._client);
     }
 
     /** Adds a connection string resource */
@@ -4269,7 +4317,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
 
     addConnectionString(name: string, options?: AddConnectionStringOptions): ResourceWithConnectionStringPromise {
         const environmentVariableName = options?.environmentVariableName;
-        return new ResourceWithConnectionStringPromiseImpl(this._addConnectionStringInternal(name, environmentVariableName));
+        return new ResourceWithConnectionStringPromiseImpl(this._addConnectionStringInternal(name, environmentVariableName), this._client);
     }
 
     /** Adds a .NET project resource */
@@ -4284,7 +4332,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     }
 
     addProject(name: string, projectPath: string, launchProfileName: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._addProjectInternal(name, projectPath, launchProfileName));
+        return new ProjectResourcePromiseImpl(this._addProjectInternal(name, projectPath, launchProfileName), this._client);
     }
 
     /** Adds a project resource with configuration options */
@@ -4304,7 +4352,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     }
 
     addProjectWithOptions(name: string, projectPath: string, configure: (obj: ProjectResourceOptions) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._addProjectWithOptionsInternal(name, projectPath, configure));
+        return new ProjectResourcePromiseImpl(this._addProjectWithOptionsInternal(name, projectPath, configure), this._client);
     }
 
     /** Adds a C# application resource */
@@ -4319,7 +4367,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     }
 
     addCSharpApp(name: string, path: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._addCSharpAppInternal(name, path));
+        return new ProjectResourcePromiseImpl(this._addCSharpAppInternal(name, path), this._client);
     }
 
     /** Adds a C# application resource with configuration options */
@@ -4339,7 +4387,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     }
 
     addCSharpAppWithOptions(name: string, path: string, configure: (obj: ProjectResourceOptions) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._addCSharpAppWithOptionsInternal(name, path, configure));
+        return new CSharpAppResourcePromiseImpl(this._addCSharpAppWithOptionsInternal(name, path, configure), this._client);
     }
 
     /** Gets the application configuration */
@@ -4354,7 +4402,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     }
 
     getConfiguration(): ConfigurationPromise {
-        return new ConfigurationPromiseImpl(this._getConfigurationInternal());
+        return new ConfigurationPromiseImpl(this._getConfigurationInternal(), this._client);
     }
 
     /** Subscribes to the BeforeStart event */
@@ -4399,7 +4447,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
 
     addTestRedis(name: string, options?: AddTestRedisOptions): TestRedisResourcePromise {
         const port = options?.port;
-        return new TestRedisResourcePromiseImpl(this._addTestRedisInternal(name, port));
+        return new TestRedisResourcePromiseImpl(this._addTestRedisInternal(name, port), this._client);
     }
 
     /** Adds a test vault resource */
@@ -4414,7 +4462,7 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
     }
 
     addTestVault(name: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._addTestVaultInternal(name));
+        return new TestVaultResourcePromiseImpl(this._addTestVaultInternal(name), this._client);
     }
 
 }
@@ -4423,7 +4471,9 @@ class DistributedApplicationBuilderImpl implements DistributedApplicationBuilder
  * Thenable wrapper for DistributedApplicationBuilder that enables fluent chaining.
  */
 class DistributedApplicationBuilderPromiseImpl implements DistributedApplicationBuilderPromise {
-    constructor(private _promise: Promise<DistributedApplicationBuilder>) {}
+    constructor(private _promise: Promise<DistributedApplicationBuilder>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = DistributedApplicationBuilder, TResult2 = never>(
         onfulfilled?: ((value: DistributedApplicationBuilder) => TResult1 | PromiseLike<TResult1>) | null,
@@ -4434,107 +4484,107 @@ class DistributedApplicationBuilderPromiseImpl implements DistributedApplication
 
     /** Builds the distributed application */
     build(): DistributedApplicationPromise {
-        return new DistributedApplicationPromiseImpl(this._promise.then(obj => obj.build()));
+        return new DistributedApplicationPromiseImpl(this._promise.then(obj => obj.build()), this._client);
     }
 
     /** Adds a connection string with a reference expression */
     addConnectionStringExpression(name: string, connectionStringExpression: ReferenceExpression): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.addConnectionStringExpression(name, connectionStringExpression)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.addConnectionStringExpression(name, connectionStringExpression)), this._client);
     }
 
     /** Adds a connection string with a builder callback */
     addConnectionStringBuilder(name: string, connectionStringBuilder: (obj: ReferenceExpressionBuilder) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.addConnectionStringBuilder(name, connectionStringBuilder)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.addConnectionStringBuilder(name, connectionStringBuilder)), this._client);
     }
 
     /** Adds a container registry resource */
-    addContainerRegistry(name: string, endpoint: ParameterResource, options?: AddContainerRegistryOptions): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.addContainerRegistry(name, endpoint, options)));
+    addContainerRegistry(name: string, endpoint: Awaitable<ParameterResource>, options?: AddContainerRegistryOptions): ContainerRegistryResourcePromise {
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.addContainerRegistry(name, endpoint, options)), this._client);
     }
 
     /** Adds a container registry with string endpoint */
     addContainerRegistryFromString(name: string, endpoint: string, options?: AddContainerRegistryFromStringOptions): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.addContainerRegistryFromString(name, endpoint, options)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.addContainerRegistryFromString(name, endpoint, options)), this._client);
     }
 
     /** Adds a container resource */
     addContainer(name: string, image: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.addContainer(name, image)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.addContainer(name, image)), this._client);
     }
 
     /** Adds a container resource built from a Dockerfile */
     addDockerfile(name: string, contextPath: string, options?: AddDockerfileOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.addDockerfile(name, contextPath, options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.addDockerfile(name, contextPath, options)), this._client);
     }
 
     /** Adds a .NET tool resource */
     addDotnetTool(name: string, packageId: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.addDotnetTool(name, packageId)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.addDotnetTool(name, packageId)), this._client);
     }
 
     /** Adds an executable resource */
     addExecutable(name: string, command: string, workingDirectory: string, args: string[]): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.addExecutable(name, command, workingDirectory, args)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.addExecutable(name, command, workingDirectory, args)), this._client);
     }
 
     /** Adds an external service resource */
     addExternalService(name: string, url: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.addExternalService(name, url)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.addExternalService(name, url)), this._client);
     }
 
     /** Adds an external service with a URI */
     addExternalServiceUri(name: string, uri: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.addExternalServiceUri(name, uri)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.addExternalServiceUri(name, uri)), this._client);
     }
 
     /** Adds an external service with a parameter URL */
-    addExternalServiceParameter(name: string, urlParameter: ParameterResource): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.addExternalServiceParameter(name, urlParameter)));
+    addExternalServiceParameter(name: string, urlParameter: Awaitable<ParameterResource>): ExternalServiceResourcePromise {
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.addExternalServiceParameter(name, urlParameter)), this._client);
     }
 
     /** Adds a parameter resource */
     addParameter(name: string, options?: AddParameterOptions): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.addParameter(name, options)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.addParameter(name, options)), this._client);
     }
 
     /** Adds a parameter with a default value */
     addParameterWithValue(name: string, value: string, options?: AddParameterWithValueOptions): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.addParameterWithValue(name, value, options)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.addParameterWithValue(name, value, options)), this._client);
     }
 
     /** Adds a parameter sourced from configuration */
     addParameterFromConfiguration(name: string, configurationKey: string, options?: AddParameterFromConfigurationOptions): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.addParameterFromConfiguration(name, configurationKey, options)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.addParameterFromConfiguration(name, configurationKey, options)), this._client);
     }
 
     /** Adds a connection string resource */
     addConnectionString(name: string, options?: AddConnectionStringOptions): ResourceWithConnectionStringPromise {
-        return new ResourceWithConnectionStringPromiseImpl(this._promise.then(obj => obj.addConnectionString(name, options)));
+        return new ResourceWithConnectionStringPromiseImpl(this._promise.then(obj => obj.addConnectionString(name, options)), this._client);
     }
 
     /** Adds a .NET project resource */
     addProject(name: string, projectPath: string, launchProfileName: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.addProject(name, projectPath, launchProfileName)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.addProject(name, projectPath, launchProfileName)), this._client);
     }
 
     /** Adds a project resource with configuration options */
     addProjectWithOptions(name: string, projectPath: string, configure: (obj: ProjectResourceOptions) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.addProjectWithOptions(name, projectPath, configure)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.addProjectWithOptions(name, projectPath, configure)), this._client);
     }
 
     /** Adds a C# application resource */
     addCSharpApp(name: string, path: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.addCSharpApp(name, path)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.addCSharpApp(name, path)), this._client);
     }
 
     /** Adds a C# application resource with configuration options */
     addCSharpAppWithOptions(name: string, path: string, configure: (obj: ProjectResourceOptions) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.addCSharpAppWithOptions(name, path, configure)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.addCSharpAppWithOptions(name, path, configure)), this._client);
     }
 
     /** Gets the application configuration */
     getConfiguration(): ConfigurationPromise {
-        return new ConfigurationPromiseImpl(this._promise.then(obj => obj.getConfiguration()));
+        return new ConfigurationPromiseImpl(this._promise.then(obj => obj.getConfiguration()), this._client);
     }
 
     /** Subscribes to the BeforeStart event */
@@ -4549,12 +4599,12 @@ class DistributedApplicationBuilderPromiseImpl implements DistributedApplication
 
     /** Adds a test Redis resource */
     addTestRedis(name: string, options?: AddTestRedisOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.addTestRedis(name, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.addTestRedis(name, options)), this._client);
     }
 
     /** Adds a test vault resource */
     addTestVault(name: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.addTestVault(name)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.addTestVault(name)), this._client);
     }
 
 }
@@ -4597,7 +4647,7 @@ class DistributedApplicationEventingImpl implements DistributedApplicationEventi
     }
 
     unsubscribe(subscription: DistributedApplicationEventSubscriptionHandle): DistributedApplicationEventingPromise {
-        return new DistributedApplicationEventingPromiseImpl(this._unsubscribeInternal(subscription));
+        return new DistributedApplicationEventingPromiseImpl(this._unsubscribeInternal(subscription), this._client);
     }
 
 }
@@ -4606,7 +4656,9 @@ class DistributedApplicationEventingImpl implements DistributedApplicationEventi
  * Thenable wrapper for DistributedApplicationEventing that enables fluent chaining.
  */
 class DistributedApplicationEventingPromiseImpl implements DistributedApplicationEventingPromise {
-    constructor(private _promise: Promise<DistributedApplicationEventing>) {}
+    constructor(private _promise: Promise<DistributedApplicationEventing>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = DistributedApplicationEventing, TResult2 = never>(
         onfulfilled?: ((value: DistributedApplicationEventing) => TResult1 | PromiseLike<TResult1>) | null,
@@ -4617,7 +4669,7 @@ class DistributedApplicationEventingPromiseImpl implements DistributedApplicatio
 
     /** Invokes the Unsubscribe method */
     unsubscribe(subscription: DistributedApplicationEventSubscriptionHandle): DistributedApplicationEventingPromise {
-        return new DistributedApplicationEventingPromiseImpl(this._promise.then(obj => obj.unsubscribe(subscription)));
+        return new DistributedApplicationEventingPromiseImpl(this._promise.then(obj => obj.unsubscribe(subscription)), this._client);
     }
 
 }
@@ -4696,7 +4748,9 @@ class HostEnvironmentImpl implements HostEnvironment {
  * Thenable wrapper for HostEnvironment that enables fluent chaining.
  */
 class HostEnvironmentPromiseImpl implements HostEnvironmentPromise {
-    constructor(private _promise: Promise<HostEnvironment>) {}
+    constructor(private _promise: Promise<HostEnvironment>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = HostEnvironment, TResult2 = never>(
         onfulfilled?: ((value: HostEnvironment) => TResult1 | PromiseLike<TResult1>) | null,
@@ -4773,7 +4827,7 @@ class LoggerImpl implements Logger {
     }
 
     logInformation(message: string): LoggerPromise {
-        return new LoggerPromiseImpl(this._logInformationInternal(message));
+        return new LoggerPromiseImpl(this._logInformationInternal(message), this._client);
     }
 
     /** Logs a warning message */
@@ -4788,7 +4842,7 @@ class LoggerImpl implements Logger {
     }
 
     logWarning(message: string): LoggerPromise {
-        return new LoggerPromiseImpl(this._logWarningInternal(message));
+        return new LoggerPromiseImpl(this._logWarningInternal(message), this._client);
     }
 
     /** Logs an error message */
@@ -4803,7 +4857,7 @@ class LoggerImpl implements Logger {
     }
 
     logError(message: string): LoggerPromise {
-        return new LoggerPromiseImpl(this._logErrorInternal(message));
+        return new LoggerPromiseImpl(this._logErrorInternal(message), this._client);
     }
 
     /** Logs a debug message */
@@ -4818,7 +4872,7 @@ class LoggerImpl implements Logger {
     }
 
     logDebug(message: string): LoggerPromise {
-        return new LoggerPromiseImpl(this._logDebugInternal(message));
+        return new LoggerPromiseImpl(this._logDebugInternal(message), this._client);
     }
 
     /** Logs a message with specified level */
@@ -4833,7 +4887,7 @@ class LoggerImpl implements Logger {
     }
 
     log(level: string, message: string): LoggerPromise {
-        return new LoggerPromiseImpl(this._logInternal(level, message));
+        return new LoggerPromiseImpl(this._logInternal(level, message), this._client);
     }
 
 }
@@ -4842,7 +4896,9 @@ class LoggerImpl implements Logger {
  * Thenable wrapper for Logger that enables fluent chaining.
  */
 class LoggerPromiseImpl implements LoggerPromise {
-    constructor(private _promise: Promise<Logger>) {}
+    constructor(private _promise: Promise<Logger>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = Logger, TResult2 = never>(
         onfulfilled?: ((value: Logger) => TResult1 | PromiseLike<TResult1>) | null,
@@ -4853,27 +4909,27 @@ class LoggerPromiseImpl implements LoggerPromise {
 
     /** Logs an information message */
     logInformation(message: string): LoggerPromise {
-        return new LoggerPromiseImpl(this._promise.then(obj => obj.logInformation(message)));
+        return new LoggerPromiseImpl(this._promise.then(obj => obj.logInformation(message)), this._client);
     }
 
     /** Logs a warning message */
     logWarning(message: string): LoggerPromise {
-        return new LoggerPromiseImpl(this._promise.then(obj => obj.logWarning(message)));
+        return new LoggerPromiseImpl(this._promise.then(obj => obj.logWarning(message)), this._client);
     }
 
     /** Logs an error message */
     logError(message: string): LoggerPromise {
-        return new LoggerPromiseImpl(this._promise.then(obj => obj.logError(message)));
+        return new LoggerPromiseImpl(this._promise.then(obj => obj.logError(message)), this._client);
     }
 
     /** Logs a debug message */
     logDebug(message: string): LoggerPromise {
-        return new LoggerPromiseImpl(this._promise.then(obj => obj.logDebug(message)));
+        return new LoggerPromiseImpl(this._promise.then(obj => obj.logDebug(message)), this._client);
     }
 
     /** Logs a message with specified level */
     log(level: string, message: string): LoggerPromise {
-        return new LoggerPromiseImpl(this._promise.then(obj => obj.log(level, message)));
+        return new LoggerPromiseImpl(this._promise.then(obj => obj.log(level, message)), this._client);
     }
 
 }
@@ -4916,7 +4972,7 @@ class LoggerFactoryImpl implements LoggerFactory {
     }
 
     createLogger(categoryName: string): LoggerPromise {
-        return new LoggerPromiseImpl(this._createLoggerInternal(categoryName));
+        return new LoggerPromiseImpl(this._createLoggerInternal(categoryName), this._client);
     }
 
 }
@@ -4925,7 +4981,9 @@ class LoggerFactoryImpl implements LoggerFactory {
  * Thenable wrapper for LoggerFactory that enables fluent chaining.
  */
 class LoggerFactoryPromiseImpl implements LoggerFactoryPromise {
-    constructor(private _promise: Promise<LoggerFactory>) {}
+    constructor(private _promise: Promise<LoggerFactory>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = LoggerFactory, TResult2 = never>(
         onfulfilled?: ((value: LoggerFactory) => TResult1 | PromiseLike<TResult1>) | null,
@@ -4936,7 +4994,7 @@ class LoggerFactoryPromiseImpl implements LoggerFactoryPromise {
 
     /** Creates a logger for a category */
     createLogger(categoryName: string): LoggerPromise {
-        return new LoggerPromiseImpl(this._promise.then(obj => obj.createLogger(categoryName)));
+        return new LoggerPromiseImpl(this._promise.then(obj => obj.createLogger(categoryName)), this._client);
     }
 
 }
@@ -4991,7 +5049,7 @@ class ReportingStepImpl implements ReportingStep {
 
     createTask(statusText: string, options?: CreateTaskOptions): ReportingTaskPromise {
         const cancellationToken = options?.cancellationToken;
-        return new ReportingTaskPromiseImpl(this._createTaskInternal(statusText, cancellationToken));
+        return new ReportingTaskPromiseImpl(this._createTaskInternal(statusText, cancellationToken), this._client);
     }
 
     /** Creates a reporting task with Markdown-formatted status text */
@@ -5008,7 +5066,7 @@ class ReportingStepImpl implements ReportingStep {
 
     createMarkdownTask(markdownString: string, options?: CreateMarkdownTaskOptions): ReportingTaskPromise {
         const cancellationToken = options?.cancellationToken;
-        return new ReportingTaskPromiseImpl(this._createMarkdownTaskInternal(markdownString, cancellationToken));
+        return new ReportingTaskPromiseImpl(this._createMarkdownTaskInternal(markdownString, cancellationToken), this._client);
     }
 
     /** Logs a plain-text message for the reporting step */
@@ -5023,7 +5081,7 @@ class ReportingStepImpl implements ReportingStep {
     }
 
     logStep(level: string, message: string): ReportingStepPromise {
-        return new ReportingStepPromiseImpl(this._logStepInternal(level, message));
+        return new ReportingStepPromiseImpl(this._logStepInternal(level, message), this._client);
     }
 
     /** Logs a Markdown-formatted message for the reporting step */
@@ -5038,7 +5096,7 @@ class ReportingStepImpl implements ReportingStep {
     }
 
     logStepMarkdown(level: string, markdownString: string): ReportingStepPromise {
-        return new ReportingStepPromiseImpl(this._logStepMarkdownInternal(level, markdownString));
+        return new ReportingStepPromiseImpl(this._logStepMarkdownInternal(level, markdownString), this._client);
     }
 
     /** Completes the reporting step with plain-text completion text */
@@ -5057,7 +5115,7 @@ class ReportingStepImpl implements ReportingStep {
     completeStep(completionText: string, options?: CompleteStepOptions): ReportingStepPromise {
         const completionState = options?.completionState;
         const cancellationToken = options?.cancellationToken;
-        return new ReportingStepPromiseImpl(this._completeStepInternal(completionText, completionState, cancellationToken));
+        return new ReportingStepPromiseImpl(this._completeStepInternal(completionText, completionState, cancellationToken), this._client);
     }
 
     /** Completes the reporting step with Markdown-formatted completion text */
@@ -5076,7 +5134,7 @@ class ReportingStepImpl implements ReportingStep {
     completeStepMarkdown(markdownString: string, options?: CompleteStepMarkdownOptions): ReportingStepPromise {
         const completionState = options?.completionState;
         const cancellationToken = options?.cancellationToken;
-        return new ReportingStepPromiseImpl(this._completeStepMarkdownInternal(markdownString, completionState, cancellationToken));
+        return new ReportingStepPromiseImpl(this._completeStepMarkdownInternal(markdownString, completionState, cancellationToken), this._client);
     }
 
 }
@@ -5085,7 +5143,9 @@ class ReportingStepImpl implements ReportingStep {
  * Thenable wrapper for ReportingStep that enables fluent chaining.
  */
 class ReportingStepPromiseImpl implements ReportingStepPromise {
-    constructor(private _promise: Promise<ReportingStep>) {}
+    constructor(private _promise: Promise<ReportingStep>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ReportingStep, TResult2 = never>(
         onfulfilled?: ((value: ReportingStep) => TResult1 | PromiseLike<TResult1>) | null,
@@ -5096,32 +5156,32 @@ class ReportingStepPromiseImpl implements ReportingStepPromise {
 
     /** Creates a reporting task with plain-text status text */
     createTask(statusText: string, options?: CreateTaskOptions): ReportingTaskPromise {
-        return new ReportingTaskPromiseImpl(this._promise.then(obj => obj.createTask(statusText, options)));
+        return new ReportingTaskPromiseImpl(this._promise.then(obj => obj.createTask(statusText, options)), this._client);
     }
 
     /** Creates a reporting task with Markdown-formatted status text */
     createMarkdownTask(markdownString: string, options?: CreateMarkdownTaskOptions): ReportingTaskPromise {
-        return new ReportingTaskPromiseImpl(this._promise.then(obj => obj.createMarkdownTask(markdownString, options)));
+        return new ReportingTaskPromiseImpl(this._promise.then(obj => obj.createMarkdownTask(markdownString, options)), this._client);
     }
 
     /** Logs a plain-text message for the reporting step */
     logStep(level: string, message: string): ReportingStepPromise {
-        return new ReportingStepPromiseImpl(this._promise.then(obj => obj.logStep(level, message)));
+        return new ReportingStepPromiseImpl(this._promise.then(obj => obj.logStep(level, message)), this._client);
     }
 
     /** Logs a Markdown-formatted message for the reporting step */
     logStepMarkdown(level: string, markdownString: string): ReportingStepPromise {
-        return new ReportingStepPromiseImpl(this._promise.then(obj => obj.logStepMarkdown(level, markdownString)));
+        return new ReportingStepPromiseImpl(this._promise.then(obj => obj.logStepMarkdown(level, markdownString)), this._client);
     }
 
     /** Completes the reporting step with plain-text completion text */
     completeStep(completionText: string, options?: CompleteStepOptions): ReportingStepPromise {
-        return new ReportingStepPromiseImpl(this._promise.then(obj => obj.completeStep(completionText, options)));
+        return new ReportingStepPromiseImpl(this._promise.then(obj => obj.completeStep(completionText, options)), this._client);
     }
 
     /** Completes the reporting step with Markdown-formatted completion text */
     completeStepMarkdown(markdownString: string, options?: CompleteStepMarkdownOptions): ReportingStepPromise {
-        return new ReportingStepPromiseImpl(this._promise.then(obj => obj.completeStepMarkdown(markdownString, options)));
+        return new ReportingStepPromiseImpl(this._promise.then(obj => obj.completeStepMarkdown(markdownString, options)), this._client);
     }
 
 }
@@ -5172,7 +5232,7 @@ class ReportingTaskImpl implements ReportingTask {
 
     updateTask(statusText: string, options?: UpdateTaskOptions): ReportingTaskPromise {
         const cancellationToken = options?.cancellationToken;
-        return new ReportingTaskPromiseImpl(this._updateTaskInternal(statusText, cancellationToken));
+        return new ReportingTaskPromiseImpl(this._updateTaskInternal(statusText, cancellationToken), this._client);
     }
 
     /** Updates the reporting task with Markdown-formatted status text */
@@ -5189,7 +5249,7 @@ class ReportingTaskImpl implements ReportingTask {
 
     updateTaskMarkdown(markdownString: string, options?: UpdateTaskMarkdownOptions): ReportingTaskPromise {
         const cancellationToken = options?.cancellationToken;
-        return new ReportingTaskPromiseImpl(this._updateTaskMarkdownInternal(markdownString, cancellationToken));
+        return new ReportingTaskPromiseImpl(this._updateTaskMarkdownInternal(markdownString, cancellationToken), this._client);
     }
 
     /** Completes the reporting task with plain-text completion text */
@@ -5210,7 +5270,7 @@ class ReportingTaskImpl implements ReportingTask {
         const completionMessage = options?.completionMessage;
         const completionState = options?.completionState;
         const cancellationToken = options?.cancellationToken;
-        return new ReportingTaskPromiseImpl(this._completeTaskInternal(completionMessage, completionState, cancellationToken));
+        return new ReportingTaskPromiseImpl(this._completeTaskInternal(completionMessage, completionState, cancellationToken), this._client);
     }
 
     /** Completes the reporting task with Markdown-formatted completion text */
@@ -5229,7 +5289,7 @@ class ReportingTaskImpl implements ReportingTask {
     completeTaskMarkdown(markdownString: string, options?: CompleteTaskMarkdownOptions): ReportingTaskPromise {
         const completionState = options?.completionState;
         const cancellationToken = options?.cancellationToken;
-        return new ReportingTaskPromiseImpl(this._completeTaskMarkdownInternal(markdownString, completionState, cancellationToken));
+        return new ReportingTaskPromiseImpl(this._completeTaskMarkdownInternal(markdownString, completionState, cancellationToken), this._client);
     }
 
 }
@@ -5238,7 +5298,9 @@ class ReportingTaskImpl implements ReportingTask {
  * Thenable wrapper for ReportingTask that enables fluent chaining.
  */
 class ReportingTaskPromiseImpl implements ReportingTaskPromise {
-    constructor(private _promise: Promise<ReportingTask>) {}
+    constructor(private _promise: Promise<ReportingTask>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ReportingTask, TResult2 = never>(
         onfulfilled?: ((value: ReportingTask) => TResult1 | PromiseLike<TResult1>) | null,
@@ -5249,22 +5311,22 @@ class ReportingTaskPromiseImpl implements ReportingTaskPromise {
 
     /** Updates the reporting task with plain-text status text */
     updateTask(statusText: string, options?: UpdateTaskOptions): ReportingTaskPromise {
-        return new ReportingTaskPromiseImpl(this._promise.then(obj => obj.updateTask(statusText, options)));
+        return new ReportingTaskPromiseImpl(this._promise.then(obj => obj.updateTask(statusText, options)), this._client);
     }
 
     /** Updates the reporting task with Markdown-formatted status text */
     updateTaskMarkdown(markdownString: string, options?: UpdateTaskMarkdownOptions): ReportingTaskPromise {
-        return new ReportingTaskPromiseImpl(this._promise.then(obj => obj.updateTaskMarkdown(markdownString, options)));
+        return new ReportingTaskPromiseImpl(this._promise.then(obj => obj.updateTaskMarkdown(markdownString, options)), this._client);
     }
 
     /** Completes the reporting task with plain-text completion text */
     completeTask(options?: CompleteTaskOptions): ReportingTaskPromise {
-        return new ReportingTaskPromiseImpl(this._promise.then(obj => obj.completeTask(options)));
+        return new ReportingTaskPromiseImpl(this._promise.then(obj => obj.completeTask(options)), this._client);
     }
 
     /** Completes the reporting task with Markdown-formatted completion text */
     completeTaskMarkdown(markdownString: string, options?: CompleteTaskMarkdownOptions): ReportingTaskPromise {
-        return new ReportingTaskPromiseImpl(this._promise.then(obj => obj.completeTaskMarkdown(markdownString, options)));
+        return new ReportingTaskPromiseImpl(this._promise.then(obj => obj.completeTaskMarkdown(markdownString, options)), this._client);
     }
 
 }
@@ -5317,7 +5379,7 @@ class ServiceProviderImpl implements ServiceProvider {
     }
 
     getEventing(): DistributedApplicationEventingPromise {
-        return new DistributedApplicationEventingPromiseImpl(this._getEventingInternal());
+        return new DistributedApplicationEventingPromiseImpl(this._getEventingInternal(), this._client);
     }
 
     /** Gets the logger factory from the service provider */
@@ -5332,7 +5394,7 @@ class ServiceProviderImpl implements ServiceProvider {
     }
 
     getLoggerFactory(): LoggerFactoryPromise {
-        return new LoggerFactoryPromiseImpl(this._getLoggerFactoryInternal());
+        return new LoggerFactoryPromiseImpl(this._getLoggerFactoryInternal(), this._client);
     }
 
     /** Gets the resource logger service from the service provider */
@@ -5347,7 +5409,7 @@ class ServiceProviderImpl implements ServiceProvider {
     }
 
     getResourceLoggerService(): ResourceLoggerServicePromise {
-        return new ResourceLoggerServicePromiseImpl(this._getResourceLoggerServiceInternal());
+        return new ResourceLoggerServicePromiseImpl(this._getResourceLoggerServiceInternal(), this._client);
     }
 
     /** Gets the distributed application model from the service provider */
@@ -5362,7 +5424,7 @@ class ServiceProviderImpl implements ServiceProvider {
     }
 
     getDistributedApplicationModel(): DistributedApplicationModelPromise {
-        return new DistributedApplicationModelPromiseImpl(this._getDistributedApplicationModelInternal());
+        return new DistributedApplicationModelPromiseImpl(this._getDistributedApplicationModelInternal(), this._client);
     }
 
     /** Gets the resource notification service from the service provider */
@@ -5377,7 +5439,7 @@ class ServiceProviderImpl implements ServiceProvider {
     }
 
     getResourceNotificationService(): ResourceNotificationServicePromise {
-        return new ResourceNotificationServicePromiseImpl(this._getResourceNotificationServiceInternal());
+        return new ResourceNotificationServicePromiseImpl(this._getResourceNotificationServiceInternal(), this._client);
     }
 
     /** Gets the user secrets manager from the service provider */
@@ -5392,7 +5454,7 @@ class ServiceProviderImpl implements ServiceProvider {
     }
 
     getUserSecretsManager(): UserSecretsManagerPromise {
-        return new UserSecretsManagerPromiseImpl(this._getUserSecretsManagerInternal());
+        return new UserSecretsManagerPromiseImpl(this._getUserSecretsManagerInternal(), this._client);
     }
 
 }
@@ -5401,7 +5463,9 @@ class ServiceProviderImpl implements ServiceProvider {
  * Thenable wrapper for ServiceProvider that enables fluent chaining.
  */
 class ServiceProviderPromiseImpl implements ServiceProviderPromise {
-    constructor(private _promise: Promise<ServiceProvider>) {}
+    constructor(private _promise: Promise<ServiceProvider>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ServiceProvider, TResult2 = never>(
         onfulfilled?: ((value: ServiceProvider) => TResult1 | PromiseLike<TResult1>) | null,
@@ -5412,32 +5476,32 @@ class ServiceProviderPromiseImpl implements ServiceProviderPromise {
 
     /** Gets the distributed application eventing service from the service provider */
     getEventing(): DistributedApplicationEventingPromise {
-        return new DistributedApplicationEventingPromiseImpl(this._promise.then(obj => obj.getEventing()));
+        return new DistributedApplicationEventingPromiseImpl(this._promise.then(obj => obj.getEventing()), this._client);
     }
 
     /** Gets the logger factory from the service provider */
     getLoggerFactory(): LoggerFactoryPromise {
-        return new LoggerFactoryPromiseImpl(this._promise.then(obj => obj.getLoggerFactory()));
+        return new LoggerFactoryPromiseImpl(this._promise.then(obj => obj.getLoggerFactory()), this._client);
     }
 
     /** Gets the resource logger service from the service provider */
     getResourceLoggerService(): ResourceLoggerServicePromise {
-        return new ResourceLoggerServicePromiseImpl(this._promise.then(obj => obj.getResourceLoggerService()));
+        return new ResourceLoggerServicePromiseImpl(this._promise.then(obj => obj.getResourceLoggerService()), this._client);
     }
 
     /** Gets the distributed application model from the service provider */
     getDistributedApplicationModel(): DistributedApplicationModelPromise {
-        return new DistributedApplicationModelPromiseImpl(this._promise.then(obj => obj.getDistributedApplicationModel()));
+        return new DistributedApplicationModelPromiseImpl(this._promise.then(obj => obj.getDistributedApplicationModel()), this._client);
     }
 
     /** Gets the resource notification service from the service provider */
     getResourceNotificationService(): ResourceNotificationServicePromise {
-        return new ResourceNotificationServicePromiseImpl(this._promise.then(obj => obj.getResourceNotificationService()));
+        return new ResourceNotificationServicePromiseImpl(this._promise.then(obj => obj.getResourceNotificationService()), this._client);
     }
 
     /** Gets the user secrets manager from the service provider */
     getUserSecretsManager(): UserSecretsManagerPromise {
-        return new UserSecretsManagerPromiseImpl(this._promise.then(obj => obj.getUserSecretsManager()));
+        return new UserSecretsManagerPromiseImpl(this._promise.then(obj => obj.getUserSecretsManager()), this._client);
     }
 
 }
@@ -5456,13 +5520,13 @@ export interface UserSecretsManager {
     };
     trySetSecret(name: string, value: string): Promise<boolean>;
     saveStateJson(json: string, options?: SaveStateJsonOptions): UserSecretsManagerPromise;
-    getOrSetSecret(resourceBuilder: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, name: string, value: string): UserSecretsManagerPromise;
+    getOrSetSecret(resourceBuilder: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, name: string, value: string): UserSecretsManagerPromise;
 }
 
 export interface UserSecretsManagerPromise extends PromiseLike<UserSecretsManager> {
     trySetSecret(name: string, value: string): Promise<boolean>;
     saveStateJson(json: string, options?: SaveStateJsonOptions): UserSecretsManagerPromise;
-    getOrSetSecret(resourceBuilder: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, name: string, value: string): UserSecretsManagerPromise;
+    getOrSetSecret(resourceBuilder: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, name: string, value: string): UserSecretsManagerPromise;
 }
 
 // ============================================================================
@@ -5521,12 +5585,13 @@ class UserSecretsManagerImpl implements UserSecretsManager {
 
     saveStateJson(json: string, options?: SaveStateJsonOptions): UserSecretsManagerPromise {
         const cancellationToken = options?.cancellationToken;
-        return new UserSecretsManagerPromiseImpl(this._saveStateJsonInternal(json, cancellationToken));
+        return new UserSecretsManagerPromiseImpl(this._saveStateJsonInternal(json, cancellationToken), this._client);
     }
 
     /** Gets a secret value if it exists, or sets it to the provided value if it does not */
     /** @internal */
-    async _getOrSetSecretInternal(resourceBuilder: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, name: string, value: string): Promise<UserSecretsManager> {
+    async _getOrSetSecretInternal(resourceBuilder: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, name: string, value: string): Promise<UserSecretsManager> {
+        resourceBuilder = isPromiseLike(resourceBuilder) ? await resourceBuilder : resourceBuilder;
         const rpcArgs: Record<string, unknown> = { userSecretsManager: this._handle, resourceBuilder, name, value };
         await this._client.invokeCapability<void>(
             'Aspire.Hosting/getOrSetSecret',
@@ -5535,8 +5600,8 @@ class UserSecretsManagerImpl implements UserSecretsManager {
         return this;
     }
 
-    getOrSetSecret(resourceBuilder: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, name: string, value: string): UserSecretsManagerPromise {
-        return new UserSecretsManagerPromiseImpl(this._getOrSetSecretInternal(resourceBuilder, name, value));
+    getOrSetSecret(resourceBuilder: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, name: string, value: string): UserSecretsManagerPromise {
+        return new UserSecretsManagerPromiseImpl(this._getOrSetSecretInternal(resourceBuilder, name, value), this._client);
     }
 
 }
@@ -5545,7 +5610,9 @@ class UserSecretsManagerImpl implements UserSecretsManager {
  * Thenable wrapper for UserSecretsManager that enables fluent chaining.
  */
 class UserSecretsManagerPromiseImpl implements UserSecretsManagerPromise {
-    constructor(private _promise: Promise<UserSecretsManager>) {}
+    constructor(private _promise: Promise<UserSecretsManager>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = UserSecretsManager, TResult2 = never>(
         onfulfilled?: ((value: UserSecretsManager) => TResult1 | PromiseLike<TResult1>) | null,
@@ -5561,12 +5628,12 @@ class UserSecretsManagerPromiseImpl implements UserSecretsManagerPromise {
 
     /** Saves state to user secrets from a JSON string */
     saveStateJson(json: string, options?: SaveStateJsonOptions): UserSecretsManagerPromise {
-        return new UserSecretsManagerPromiseImpl(this._promise.then(obj => obj.saveStateJson(json, options)));
+        return new UserSecretsManagerPromiseImpl(this._promise.then(obj => obj.saveStateJson(json, options)), this._client);
     }
 
     /** Gets a secret value if it exists, or sets it to the provided value if it does not */
-    getOrSetSecret(resourceBuilder: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, name: string, value: string): UserSecretsManagerPromise {
-        return new UserSecretsManagerPromiseImpl(this._promise.then(obj => obj.getOrSetSecret(resourceBuilder, name, value)));
+    getOrSetSecret(resourceBuilder: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, name: string, value: string): UserSecretsManagerPromise {
+        return new UserSecretsManagerPromiseImpl(this._promise.then(obj => obj.getOrSetSecret(resourceBuilder, name, value)), this._client);
     }
 
 }
@@ -5577,7 +5644,7 @@ class UserSecretsManagerPromiseImpl implements UserSecretsManagerPromise {
 
 export interface ConnectionStringResource {
     toJSON(): MarshalledHandle;
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ConnectionStringResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ConnectionStringResourcePromise;
     withConnectionProperty(name: string, value: ReferenceExpression): ConnectionStringResourcePromise;
@@ -5588,16 +5655,16 @@ export interface ConnectionStringResource {
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ConnectionStringResourcePromise;
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ConnectionStringResourcePromise;
     excludeFromManifest(): ConnectionStringResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ConnectionStringResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ConnectionStringResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ConnectionStringResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ConnectionStringResourcePromise;
     withExplicitStart(): ConnectionStringResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ConnectionStringResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ConnectionStringResourcePromise;
     withHealthCheck(key: string): ConnectionStringResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ConnectionStringResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): ConnectionStringResourcePromise;
     excludeFromMcp(): ConnectionStringResourcePromise;
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ConnectionStringResourcePromise;
@@ -5618,10 +5685,10 @@ export interface ConnectionStringResource {
     withStatus(status: TestResourceStatus): ConnectionStringResourcePromise;
     withNestedConfig(config: TestNestedDto): ConnectionStringResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ConnectionStringResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise;
     withConnectionStringDirect(connectionString: string): ConnectionStringResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ConnectionStringResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ConnectionStringResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ConnectionStringResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ConnectionStringResourcePromise;
     withEndpoints(endpoints: string[]): ConnectionStringResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ConnectionStringResourcePromise;
     withMergeLabel(label: string): ConnectionStringResourcePromise;
@@ -5635,7 +5702,7 @@ export interface ConnectionStringResource {
 }
 
 export interface ConnectionStringResourcePromise extends PromiseLike<ConnectionStringResource> {
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ConnectionStringResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ConnectionStringResourcePromise;
     withConnectionProperty(name: string, value: ReferenceExpression): ConnectionStringResourcePromise;
@@ -5646,16 +5713,16 @@ export interface ConnectionStringResourcePromise extends PromiseLike<ConnectionS
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ConnectionStringResourcePromise;
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ConnectionStringResourcePromise;
     excludeFromManifest(): ConnectionStringResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ConnectionStringResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ConnectionStringResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ConnectionStringResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ConnectionStringResourcePromise;
     withExplicitStart(): ConnectionStringResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ConnectionStringResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ConnectionStringResourcePromise;
     withHealthCheck(key: string): ConnectionStringResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ConnectionStringResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): ConnectionStringResourcePromise;
     excludeFromMcp(): ConnectionStringResourcePromise;
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ConnectionStringResourcePromise;
@@ -5676,10 +5743,10 @@ export interface ConnectionStringResourcePromise extends PromiseLike<ConnectionS
     withStatus(status: TestResourceStatus): ConnectionStringResourcePromise;
     withNestedConfig(config: TestNestedDto): ConnectionStringResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ConnectionStringResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise;
     withConnectionStringDirect(connectionString: string): ConnectionStringResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ConnectionStringResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ConnectionStringResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ConnectionStringResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ConnectionStringResourcePromise;
     withEndpoints(endpoints: string[]): ConnectionStringResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ConnectionStringResourcePromise;
     withMergeLabel(label: string): ConnectionStringResourcePromise;
@@ -5702,7 +5769,8 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     }
 
     /** @internal */
-    private async _withContainerRegistryInternal(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ConnectionStringResource> {
+    private async _withContainerRegistryInternal(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ConnectionStringResource> {
+        registry = isPromiseLike(registry) ? await registry : registry;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, registry };
         const result = await this._client.invokeCapability<ConnectionStringResourceHandle>(
             'Aspire.Hosting/withContainerRegistry',
@@ -5712,8 +5780,8 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withContainerRegistryInternal(registry));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._withContainerRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -5732,7 +5800,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ConnectionStringResourcePromise {
         const buildImage = options?.buildImage;
         const runtimeImage = options?.runtimeImage;
-        return new ConnectionStringResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage));
+        return new ConnectionStringResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage), this._client);
     }
 
     /** @internal */
@@ -5749,7 +5817,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ConnectionStringResourcePromise {
         const helpLink = options?.helpLink;
-        return new ConnectionStringResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink));
+        return new ConnectionStringResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink), this._client);
     }
 
     /** @internal */
@@ -5764,7 +5832,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Adds a connection property with a reference expression */
     withConnectionProperty(name: string, value: ReferenceExpression): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withConnectionPropertyInternal(name, value));
+        return new ConnectionStringResourcePromiseImpl(this._withConnectionPropertyInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -5779,7 +5847,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Adds a connection property with a string value */
     withConnectionPropertyValue(name: string, value: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withConnectionPropertyValueInternal(name, value));
+        return new ConnectionStringResourcePromiseImpl(this._withConnectionPropertyValueInternal(name, value), this._client);
     }
 
     /** Gets a connection property by key */
@@ -5808,7 +5876,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withUrlsCallbackInternal(callback));
+        return new ConnectionStringResourcePromiseImpl(this._withUrlsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -5825,7 +5893,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): ConnectionStringResourcePromise {
         const displayText = options?.displayText;
-        return new ConnectionStringResourcePromiseImpl(this._withUrlInternal(url, displayText));
+        return new ConnectionStringResourcePromiseImpl(this._withUrlInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -5842,7 +5910,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ConnectionStringResourcePromise {
         const displayText = options?.displayText;
-        return new ConnectionStringResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText));
+        return new ConnectionStringResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -5861,7 +5929,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback));
+        return new ConnectionStringResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -5876,11 +5944,12 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._excludeFromManifestInternal());
+        return new ConnectionStringResourcePromiseImpl(this._excludeFromManifestInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ConnectionStringResource> {
+    private async _waitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ConnectionStringResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ConnectionStringResourceHandle>(
             'Aspire.Hosting/waitForResource',
@@ -5890,12 +5959,13 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._waitForInternal(dependency));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._waitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<ConnectionStringResource> {
+    private async _waitForWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<ConnectionStringResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<ConnectionStringResourceHandle>(
             'Aspire.Hosting/waitForWithBehavior',
@@ -5905,12 +5975,13 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
-    private async _waitForStartInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ConnectionStringResource> {
+    private async _waitForStartInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ConnectionStringResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ConnectionStringResourceHandle>(
             'Aspire.Hosting/waitForResourceStart',
@@ -5920,12 +5991,13 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._waitForStartInternal(dependency));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._waitForStartInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForStartWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<ConnectionStringResource> {
+    private async _waitForStartWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<ConnectionStringResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<ConnectionStringResourceHandle>(
             'Aspire.Hosting/waitForStartWithBehavior',
@@ -5935,8 +6007,8 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
@@ -5951,11 +6023,12 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withExplicitStartInternal());
+        return new ConnectionStringResourcePromiseImpl(this._withExplicitStartInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForCompletionInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, exitCode?: number): Promise<ConnectionStringResource> {
+    private async _waitForCompletionInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, exitCode?: number): Promise<ConnectionStringResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         if (exitCode !== undefined) rpcArgs.exitCode = exitCode;
         const result = await this._client.invokeCapability<ConnectionStringResourceHandle>(
@@ -5966,9 +6039,9 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ConnectionStringResourcePromise {
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ConnectionStringResourcePromise {
         const exitCode = options?.exitCode;
-        return new ConnectionStringResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode));
+        return new ConnectionStringResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode), this._client);
     }
 
     /** @internal */
@@ -5983,7 +6056,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Adds a health check by key */
     withHealthCheck(key: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withHealthCheckInternal(key));
+        return new ConnectionStringResourcePromiseImpl(this._withHealthCheckInternal(key), this._client);
     }
 
     /** @internal */
@@ -6005,11 +6078,12 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ConnectionStringResourcePromise {
         const commandOptions = options?.commandOptions;
-        return new ConnectionStringResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions));
+        return new ConnectionStringResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions), this._client);
     }
 
     /** @internal */
-    private async _withParentRelationshipInternal(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ConnectionStringResource> {
+    private async _withParentRelationshipInternal(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ConnectionStringResource> {
+        parent = isPromiseLike(parent) ? await parent : parent;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, parent };
         const result = await this._client.invokeCapability<ConnectionStringResourceHandle>(
             'Aspire.Hosting/withBuilderParentRelationship',
@@ -6019,12 +6093,13 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withParentRelationshipInternal(parent));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._withParentRelationshipInternal(parent), this._client);
     }
 
     /** @internal */
-    private async _withChildRelationshipInternal(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ConnectionStringResource> {
+    private async _withChildRelationshipInternal(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ConnectionStringResource> {
+        child = isPromiseLike(child) ? await child : child;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, child };
         const result = await this._client.invokeCapability<ConnectionStringResourceHandle>(
             'Aspire.Hosting/withBuilderChildRelationship',
@@ -6034,8 +6109,8 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withChildRelationshipInternal(child));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._withChildRelationshipInternal(child), this._client);
     }
 
     /** @internal */
@@ -6052,7 +6127,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): ConnectionStringResourcePromise {
         const iconVariant = options?.iconVariant;
-        return new ConnectionStringResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant));
+        return new ConnectionStringResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant), this._client);
     }
 
     /** @internal */
@@ -6067,7 +6142,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._excludeFromMcpInternal());
+        return new ConnectionStringResourcePromiseImpl(this._excludeFromMcpInternal(), this._client);
     }
 
     /** @internal */
@@ -6095,7 +6170,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
         const requiredBy = options?.requiredBy;
         const tags = options?.tags;
         const description = options?.description;
-        return new ConnectionStringResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description));
+        return new ConnectionStringResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description), this._client);
     }
 
     /** @internal */
@@ -6115,7 +6190,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withPipelineConfigurationInternal(callback));
+        return new ConnectionStringResourcePromiseImpl(this._withPipelineConfigurationInternal(callback), this._client);
     }
 
     /** Gets the resource name */
@@ -6144,7 +6219,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback));
+        return new ConnectionStringResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -6164,7 +6239,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._onResourceStoppedInternal(callback));
+        return new ConnectionStringResourcePromiseImpl(this._onResourceStoppedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -6184,7 +6259,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Subscribes to the ConnectionStringAvailable event */
     onConnectionStringAvailable(callback: (arg: ConnectionStringAvailableEvent) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._onConnectionStringAvailableInternal(callback));
+        return new ConnectionStringResourcePromiseImpl(this._onConnectionStringAvailableInternal(callback), this._client);
     }
 
     /** @internal */
@@ -6204,7 +6279,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._onInitializeResourceInternal(callback));
+        return new ConnectionStringResourcePromiseImpl(this._onInitializeResourceInternal(callback), this._client);
     }
 
     /** @internal */
@@ -6224,7 +6299,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._onResourceReadyInternal(callback));
+        return new ConnectionStringResourcePromiseImpl(this._onResourceReadyInternal(callback), this._client);
     }
 
     /** @internal */
@@ -6243,7 +6318,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     withOptionalString(options?: WithOptionalStringOptions): ConnectionStringResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new ConnectionStringResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new ConnectionStringResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -6258,7 +6333,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withConfigInternal(config));
+        return new ConnectionStringResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -6273,7 +6348,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Sets the connection string using a reference expression */
     withConnectionString(connectionString: ReferenceExpression): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withConnectionStringInternal(connectionString));
+        return new ConnectionStringResourcePromiseImpl(this._withConnectionStringInternal(connectionString), this._client);
     }
 
     /** @internal */
@@ -6288,7 +6363,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new ConnectionStringResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -6303,7 +6378,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new ConnectionStringResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -6318,7 +6393,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new ConnectionStringResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -6340,7 +6415,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ConnectionStringResourcePromise {
         const callback = options?.callback;
-        return new ConnectionStringResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new ConnectionStringResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -6355,7 +6430,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withStatusInternal(status));
+        return new ConnectionStringResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -6370,7 +6445,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new ConnectionStringResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -6390,11 +6465,12 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new ConnectionStringResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ConnectionStringResource> {
+    private async _testWaitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ConnectionStringResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ConnectionStringResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -6404,8 +6480,8 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -6420,11 +6496,12 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Sets connection string using direct interface target */
     withConnectionStringDirect(connectionString: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withConnectionStringDirectInternal(connectionString));
+        return new ConnectionStringResourcePromiseImpl(this._withConnectionStringDirectInternal(connectionString), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ConnectionStringResource> {
+    private async _withDependencyInternal(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ConnectionStringResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ConnectionStringResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -6434,12 +6511,13 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ConnectionStringResource> {
+    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ConnectionStringResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ConnectionStringResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -6449,8 +6527,8 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -6465,7 +6543,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new ConnectionStringResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -6484,7 +6562,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new ConnectionStringResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** @internal */
@@ -6499,7 +6577,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new ConnectionStringResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -6514,7 +6592,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new ConnectionStringResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -6529,7 +6607,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new ConnectionStringResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -6544,7 +6622,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new ConnectionStringResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -6563,7 +6641,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ConnectionStringResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ConnectionStringResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new ConnectionStringResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -6582,7 +6660,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ConnectionStringResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ConnectionStringResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new ConnectionStringResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -6597,7 +6675,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new ConnectionStringResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -6612,7 +6690,7 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new ConnectionStringResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -6623,7 +6701,9 @@ class ConnectionStringResourceImpl extends ResourceBuilderBase<ConnectionStringR
  * await builder.addSomething().withX().withY();
  */
 class ConnectionStringResourcePromiseImpl implements ConnectionStringResourcePromise {
-    constructor(private _promise: Promise<ConnectionStringResource>) {}
+    constructor(private _promise: Promise<ConnectionStringResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ConnectionStringResource, TResult2 = never>(
         onfulfilled?: ((value: ConnectionStringResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -6633,28 +6713,28 @@ class ConnectionStringResourcePromiseImpl implements ConnectionStringResourcePro
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)), this._client);
     }
 
     /** Sets the base image for a Dockerfile build */
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)), this._client);
     }
 
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)), this._client);
     }
 
     /** Adds a connection property with a reference expression */
     withConnectionProperty(name: string, value: ReferenceExpression): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withConnectionProperty(name, value)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withConnectionProperty(name, value)), this._client);
     }
 
     /** Adds a connection property with a string value */
     withConnectionPropertyValue(name: string, value: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withConnectionPropertyValue(name, value)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withConnectionPropertyValue(name, value)), this._client);
     }
 
     /** Gets a connection property by key */
@@ -6664,97 +6744,97 @@ class ConnectionStringResourcePromiseImpl implements ConnectionStringResourcePro
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)), this._client);
     }
 
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)), this._client);
     }
 
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)), this._client);
     }
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)), this._client);
     }
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()), this._client);
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)), this._client);
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)), this._client);
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()), this._client);
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)));
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)), this._client);
     }
 
     /** Adds a health check by key */
     withHealthCheck(key: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)), this._client);
     }
 
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)), this._client);
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)), this._client);
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)), this._client);
     }
 
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)), this._client);
     }
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()), this._client);
     }
 
     /** Adds a pipeline step to the resource */
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)), this._client);
     }
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)), this._client);
     }
 
     /** Gets the resource name */
@@ -6764,147 +6844,147 @@ class ConnectionStringResourcePromiseImpl implements ConnectionStringResourcePro
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)), this._client);
     }
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)), this._client);
     }
 
     /** Subscribes to the ConnectionStringAvailable event */
     onConnectionStringAvailable(callback: (arg: ConnectionStringAvailableEvent) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.onConnectionStringAvailable(callback)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.onConnectionStringAvailable(callback)), this._client);
     }
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)), this._client);
     }
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)), this._client);
     }
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Sets the connection string using a reference expression */
     withConnectionString(connectionString: ReferenceExpression): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withConnectionString(connectionString)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withConnectionString(connectionString)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Sets connection string using direct interface target */
     withConnectionStringDirect(connectionString: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withConnectionStringDirect(connectionString)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withConnectionStringDirect(connectionString)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ConnectionStringResourcePromise {
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ConnectionStringResourcePromise {
-        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new ConnectionStringResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -6915,7 +6995,7 @@ class ConnectionStringResourcePromiseImpl implements ConnectionStringResourcePro
 
 export interface ContainerRegistryResource {
     toJSON(): MarshalledHandle;
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerRegistryResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerRegistryResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ContainerRegistryResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ContainerRegistryResourcePromise;
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ContainerRegistryResourcePromise;
@@ -6926,8 +7006,8 @@ export interface ContainerRegistryResource {
     withExplicitStart(): ContainerRegistryResourcePromise;
     withHealthCheck(key: string): ContainerRegistryResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ContainerRegistryResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerRegistryResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerRegistryResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerRegistryResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerRegistryResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): ContainerRegistryResourcePromise;
     excludeFromMcp(): ContainerRegistryResourcePromise;
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ContainerRegistryResourcePromise;
@@ -6946,9 +7026,9 @@ export interface ContainerRegistryResource {
     withStatus(status: TestResourceStatus): ContainerRegistryResourcePromise;
     withNestedConfig(config: TestNestedDto): ContainerRegistryResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ContainerRegistryResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerRegistryResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerRegistryResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerRegistryResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerRegistryResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerRegistryResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerRegistryResourcePromise;
     withEndpoints(endpoints: string[]): ContainerRegistryResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ContainerRegistryResourcePromise;
     withMergeLabel(label: string): ContainerRegistryResourcePromise;
@@ -6962,7 +7042,7 @@ export interface ContainerRegistryResource {
 }
 
 export interface ContainerRegistryResourcePromise extends PromiseLike<ContainerRegistryResource> {
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerRegistryResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerRegistryResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ContainerRegistryResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ContainerRegistryResourcePromise;
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ContainerRegistryResourcePromise;
@@ -6973,8 +7053,8 @@ export interface ContainerRegistryResourcePromise extends PromiseLike<ContainerR
     withExplicitStart(): ContainerRegistryResourcePromise;
     withHealthCheck(key: string): ContainerRegistryResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ContainerRegistryResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerRegistryResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerRegistryResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerRegistryResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerRegistryResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): ContainerRegistryResourcePromise;
     excludeFromMcp(): ContainerRegistryResourcePromise;
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ContainerRegistryResourcePromise;
@@ -6993,9 +7073,9 @@ export interface ContainerRegistryResourcePromise extends PromiseLike<ContainerR
     withStatus(status: TestResourceStatus): ContainerRegistryResourcePromise;
     withNestedConfig(config: TestNestedDto): ContainerRegistryResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ContainerRegistryResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerRegistryResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerRegistryResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerRegistryResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerRegistryResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerRegistryResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerRegistryResourcePromise;
     withEndpoints(endpoints: string[]): ContainerRegistryResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ContainerRegistryResourcePromise;
     withMergeLabel(label: string): ContainerRegistryResourcePromise;
@@ -7018,7 +7098,8 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     }
 
     /** @internal */
-    private async _withContainerRegistryInternal(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ContainerRegistryResource> {
+    private async _withContainerRegistryInternal(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ContainerRegistryResource> {
+        registry = isPromiseLike(registry) ? await registry : registry;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, registry };
         const result = await this._client.invokeCapability<ContainerRegistryResourceHandle>(
             'Aspire.Hosting/withContainerRegistry',
@@ -7028,8 +7109,8 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withContainerRegistryInternal(registry));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerRegistryResourcePromise {
+        return new ContainerRegistryResourcePromiseImpl(this._withContainerRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -7048,7 +7129,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ContainerRegistryResourcePromise {
         const buildImage = options?.buildImage;
         const runtimeImage = options?.runtimeImage;
-        return new ContainerRegistryResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage));
+        return new ContainerRegistryResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage), this._client);
     }
 
     /** @internal */
@@ -7065,7 +7146,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ContainerRegistryResourcePromise {
         const helpLink = options?.helpLink;
-        return new ContainerRegistryResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink));
+        return new ContainerRegistryResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink), this._client);
     }
 
     /** @internal */
@@ -7085,7 +7166,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withUrlsCallbackInternal(callback));
+        return new ContainerRegistryResourcePromiseImpl(this._withUrlsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -7102,7 +7183,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): ContainerRegistryResourcePromise {
         const displayText = options?.displayText;
-        return new ContainerRegistryResourcePromiseImpl(this._withUrlInternal(url, displayText));
+        return new ContainerRegistryResourcePromiseImpl(this._withUrlInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -7119,7 +7200,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ContainerRegistryResourcePromise {
         const displayText = options?.displayText;
-        return new ContainerRegistryResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText));
+        return new ContainerRegistryResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -7138,7 +7219,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback));
+        return new ContainerRegistryResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -7153,7 +7234,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._excludeFromManifestInternal());
+        return new ContainerRegistryResourcePromiseImpl(this._excludeFromManifestInternal(), this._client);
     }
 
     /** @internal */
@@ -7168,7 +7249,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withExplicitStartInternal());
+        return new ContainerRegistryResourcePromiseImpl(this._withExplicitStartInternal(), this._client);
     }
 
     /** @internal */
@@ -7183,7 +7264,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Adds a health check by key */
     withHealthCheck(key: string): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withHealthCheckInternal(key));
+        return new ContainerRegistryResourcePromiseImpl(this._withHealthCheckInternal(key), this._client);
     }
 
     /** @internal */
@@ -7205,11 +7286,12 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ContainerRegistryResourcePromise {
         const commandOptions = options?.commandOptions;
-        return new ContainerRegistryResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions));
+        return new ContainerRegistryResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions), this._client);
     }
 
     /** @internal */
-    private async _withParentRelationshipInternal(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ContainerRegistryResource> {
+    private async _withParentRelationshipInternal(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ContainerRegistryResource> {
+        parent = isPromiseLike(parent) ? await parent : parent;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, parent };
         const result = await this._client.invokeCapability<ContainerRegistryResourceHandle>(
             'Aspire.Hosting/withBuilderParentRelationship',
@@ -7219,12 +7301,13 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withParentRelationshipInternal(parent));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerRegistryResourcePromise {
+        return new ContainerRegistryResourcePromiseImpl(this._withParentRelationshipInternal(parent), this._client);
     }
 
     /** @internal */
-    private async _withChildRelationshipInternal(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ContainerRegistryResource> {
+    private async _withChildRelationshipInternal(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ContainerRegistryResource> {
+        child = isPromiseLike(child) ? await child : child;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, child };
         const result = await this._client.invokeCapability<ContainerRegistryResourceHandle>(
             'Aspire.Hosting/withBuilderChildRelationship',
@@ -7234,8 +7317,8 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withChildRelationshipInternal(child));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerRegistryResourcePromise {
+        return new ContainerRegistryResourcePromiseImpl(this._withChildRelationshipInternal(child), this._client);
     }
 
     /** @internal */
@@ -7252,7 +7335,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): ContainerRegistryResourcePromise {
         const iconVariant = options?.iconVariant;
-        return new ContainerRegistryResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant));
+        return new ContainerRegistryResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant), this._client);
     }
 
     /** @internal */
@@ -7267,7 +7350,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._excludeFromMcpInternal());
+        return new ContainerRegistryResourcePromiseImpl(this._excludeFromMcpInternal(), this._client);
     }
 
     /** @internal */
@@ -7295,7 +7378,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
         const requiredBy = options?.requiredBy;
         const tags = options?.tags;
         const description = options?.description;
-        return new ContainerRegistryResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description));
+        return new ContainerRegistryResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description), this._client);
     }
 
     /** @internal */
@@ -7315,7 +7398,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withPipelineConfigurationInternal(callback));
+        return new ContainerRegistryResourcePromiseImpl(this._withPipelineConfigurationInternal(callback), this._client);
     }
 
     /** Gets the resource name */
@@ -7344,7 +7427,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback));
+        return new ContainerRegistryResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -7364,7 +7447,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._onResourceStoppedInternal(callback));
+        return new ContainerRegistryResourcePromiseImpl(this._onResourceStoppedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -7384,7 +7467,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._onInitializeResourceInternal(callback));
+        return new ContainerRegistryResourcePromiseImpl(this._onInitializeResourceInternal(callback), this._client);
     }
 
     /** @internal */
@@ -7404,7 +7487,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._onResourceReadyInternal(callback));
+        return new ContainerRegistryResourcePromiseImpl(this._onResourceReadyInternal(callback), this._client);
     }
 
     /** @internal */
@@ -7423,7 +7506,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     withOptionalString(options?: WithOptionalStringOptions): ContainerRegistryResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new ContainerRegistryResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new ContainerRegistryResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -7438,7 +7521,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withConfigInternal(config));
+        return new ContainerRegistryResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -7453,7 +7536,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new ContainerRegistryResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -7468,7 +7551,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new ContainerRegistryResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -7483,7 +7566,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new ContainerRegistryResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -7505,7 +7588,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ContainerRegistryResourcePromise {
         const callback = options?.callback;
-        return new ContainerRegistryResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new ContainerRegistryResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -7520,7 +7603,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withStatusInternal(status));
+        return new ContainerRegistryResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -7535,7 +7618,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new ContainerRegistryResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -7555,11 +7638,12 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new ContainerRegistryResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ContainerRegistryResource> {
+    private async _testWaitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ContainerRegistryResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ContainerRegistryResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -7569,12 +7653,13 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerRegistryResourcePromise {
+        return new ContainerRegistryResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ContainerRegistryResource> {
+    private async _withDependencyInternal(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ContainerRegistryResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ContainerRegistryResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -7584,12 +7669,13 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerRegistryResourcePromise {
+        return new ContainerRegistryResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ContainerRegistryResource> {
+    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ContainerRegistryResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ContainerRegistryResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -7599,8 +7685,8 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerRegistryResourcePromise {
+        return new ContainerRegistryResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -7615,7 +7701,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new ContainerRegistryResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -7634,7 +7720,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new ContainerRegistryResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** @internal */
@@ -7649,7 +7735,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new ContainerRegistryResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -7664,7 +7750,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new ContainerRegistryResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -7679,7 +7765,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new ContainerRegistryResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -7694,7 +7780,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new ContainerRegistryResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -7713,7 +7799,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ContainerRegistryResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ContainerRegistryResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new ContainerRegistryResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -7732,7 +7818,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ContainerRegistryResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ContainerRegistryResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new ContainerRegistryResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -7747,7 +7833,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new ContainerRegistryResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -7762,7 +7848,7 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new ContainerRegistryResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -7773,7 +7859,9 @@ class ContainerRegistryResourceImpl extends ResourceBuilderBase<ContainerRegistr
  * await builder.addSomething().withX().withY();
  */
 class ContainerRegistryResourcePromiseImpl implements ContainerRegistryResourcePromise {
-    constructor(private _promise: Promise<ContainerRegistryResource>) {}
+    constructor(private _promise: Promise<ContainerRegistryResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ContainerRegistryResource, TResult2 = never>(
         onfulfilled?: ((value: ContainerRegistryResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -7783,88 +7871,88 @@ class ContainerRegistryResourcePromiseImpl implements ContainerRegistryResourceP
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerRegistryResourcePromise {
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)), this._client);
     }
 
     /** Sets the base image for a Dockerfile build */
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)), this._client);
     }
 
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)), this._client);
     }
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)), this._client);
     }
 
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)), this._client);
     }
 
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)), this._client);
     }
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)), this._client);
     }
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()), this._client);
     }
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()), this._client);
     }
 
     /** Adds a health check by key */
     withHealthCheck(key: string): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)), this._client);
     }
 
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)), this._client);
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerRegistryResourcePromise {
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)), this._client);
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerRegistryResourcePromise {
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)), this._client);
     }
 
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)), this._client);
     }
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()), this._client);
     }
 
     /** Adds a pipeline step to the resource */
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)), this._client);
     }
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)), this._client);
     }
 
     /** Gets the resource name */
@@ -7874,132 +7962,132 @@ class ContainerRegistryResourcePromiseImpl implements ContainerRegistryResourceP
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)), this._client);
     }
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)), this._client);
     }
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)), this._client);
     }
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)), this._client);
     }
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerRegistryResourcePromise {
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerRegistryResourcePromise {
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerRegistryResourcePromise {
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ContainerRegistryResourcePromise {
-        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new ContainerRegistryResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -8010,7 +8098,7 @@ class ContainerRegistryResourcePromiseImpl implements ContainerRegistryResourceP
 
 export interface ContainerResource {
     toJSON(): MarshalledHandle;
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise;
     withBindMount(source: string, target: string, options?: WithBindMountOptions): ContainerResourcePromise;
     withEntrypoint(entrypoint: string): ContainerResourcePromise;
     withImageTag(tag: string): ContainerResourcePromise;
@@ -8023,8 +8111,8 @@ export interface ContainerResource {
     publishAsContainer(): ContainerResourcePromise;
     withDockerfile(contextPath: string, options?: WithDockerfileOptions): ContainerResourcePromise;
     withContainerName(name: string): ContainerResourcePromise;
-    withBuildArg(name: string, value: ParameterResource): ContainerResourcePromise;
-    withBuildSecret(name: string, value: ParameterResource): ContainerResourcePromise;
+    withBuildArg(name: string, value: Awaitable<ParameterResource>): ContainerResourcePromise;
+    withBuildSecret(name: string, value: Awaitable<ParameterResource>): ContainerResourcePromise;
     withEndpointProxySupport(proxyEnabled: boolean): ContainerResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ContainerResourcePromise;
     withContainerNetworkAlias(alias: string): ContainerResourcePromise;
@@ -8033,18 +8121,18 @@ export interface ContainerResource {
     withOtlpExporterProtocol(protocol: OtlpProtocol): ContainerResourcePromise;
     publishAsConnectionString(): ContainerResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ContainerResourcePromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): ContainerResourcePromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): ContainerResourcePromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): ContainerResourcePromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): ContainerResourcePromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): ContainerResourcePromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): ContainerResourcePromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerResourcePromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): ContainerResourcePromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): ContainerResourcePromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerResourcePromise;
     withArgs(args: string[]): ContainerResourcePromise;
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): ContainerResourcePromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): ContainerResourcePromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): ContainerResourcePromise;
     withReferenceUri(name: string, uri: string): ContainerResourcePromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): ContainerResourcePromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): ContainerResourcePromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): ContainerResourcePromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): ContainerResourcePromise;
     withEndpoint(options?: WithEndpointOptions): ContainerResourcePromise;
     withHttpEndpoint(options?: WithHttpEndpointOptions): ContainerResourcePromise;
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): ContainerResourcePromise;
@@ -8057,12 +8145,12 @@ export interface ContainerResource {
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ContainerResourcePromise;
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): ContainerResourcePromise;
     excludeFromManifest(): ContainerResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ContainerResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ContainerResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ContainerResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ContainerResourcePromise;
     withExplicitStart(): ContainerResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ContainerResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ContainerResourcePromise;
     withHealthCheck(key: string): ContainerResourcePromise;
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): ContainerResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ContainerResourcePromise;
@@ -8070,8 +8158,8 @@ export interface ContainerResource {
     withCertificateTrustScope(scope: CertificateTrustScope): ContainerResourcePromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): ContainerResourcePromise;
     withoutHttpsCertificate(): ContainerResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): ContainerResourcePromise;
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): ContainerResourcePromise;
     excludeFromMcp(): ContainerResourcePromise;
@@ -8096,9 +8184,9 @@ export interface ContainerResource {
     withStatus(status: TestResourceStatus): ContainerResourcePromise;
     withNestedConfig(config: TestNestedDto): ContainerResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ContainerResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerResourcePromise;
     withEndpoints(endpoints: string[]): ContainerResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): ContainerResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ContainerResourcePromise;
@@ -8113,7 +8201,7 @@ export interface ContainerResource {
 }
 
 export interface ContainerResourcePromise extends PromiseLike<ContainerResource> {
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise;
     withBindMount(source: string, target: string, options?: WithBindMountOptions): ContainerResourcePromise;
     withEntrypoint(entrypoint: string): ContainerResourcePromise;
     withImageTag(tag: string): ContainerResourcePromise;
@@ -8126,8 +8214,8 @@ export interface ContainerResourcePromise extends PromiseLike<ContainerResource>
     publishAsContainer(): ContainerResourcePromise;
     withDockerfile(contextPath: string, options?: WithDockerfileOptions): ContainerResourcePromise;
     withContainerName(name: string): ContainerResourcePromise;
-    withBuildArg(name: string, value: ParameterResource): ContainerResourcePromise;
-    withBuildSecret(name: string, value: ParameterResource): ContainerResourcePromise;
+    withBuildArg(name: string, value: Awaitable<ParameterResource>): ContainerResourcePromise;
+    withBuildSecret(name: string, value: Awaitable<ParameterResource>): ContainerResourcePromise;
     withEndpointProxySupport(proxyEnabled: boolean): ContainerResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ContainerResourcePromise;
     withContainerNetworkAlias(alias: string): ContainerResourcePromise;
@@ -8136,18 +8224,18 @@ export interface ContainerResourcePromise extends PromiseLike<ContainerResource>
     withOtlpExporterProtocol(protocol: OtlpProtocol): ContainerResourcePromise;
     publishAsConnectionString(): ContainerResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ContainerResourcePromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): ContainerResourcePromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): ContainerResourcePromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): ContainerResourcePromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): ContainerResourcePromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): ContainerResourcePromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): ContainerResourcePromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerResourcePromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): ContainerResourcePromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): ContainerResourcePromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerResourcePromise;
     withArgs(args: string[]): ContainerResourcePromise;
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): ContainerResourcePromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): ContainerResourcePromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): ContainerResourcePromise;
     withReferenceUri(name: string, uri: string): ContainerResourcePromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): ContainerResourcePromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): ContainerResourcePromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): ContainerResourcePromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): ContainerResourcePromise;
     withEndpoint(options?: WithEndpointOptions): ContainerResourcePromise;
     withHttpEndpoint(options?: WithHttpEndpointOptions): ContainerResourcePromise;
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): ContainerResourcePromise;
@@ -8160,12 +8248,12 @@ export interface ContainerResourcePromise extends PromiseLike<ContainerResource>
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ContainerResourcePromise;
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): ContainerResourcePromise;
     excludeFromManifest(): ContainerResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ContainerResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ContainerResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ContainerResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ContainerResourcePromise;
     withExplicitStart(): ContainerResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ContainerResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ContainerResourcePromise;
     withHealthCheck(key: string): ContainerResourcePromise;
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): ContainerResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ContainerResourcePromise;
@@ -8173,8 +8261,8 @@ export interface ContainerResourcePromise extends PromiseLike<ContainerResource>
     withCertificateTrustScope(scope: CertificateTrustScope): ContainerResourcePromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): ContainerResourcePromise;
     withoutHttpsCertificate(): ContainerResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): ContainerResourcePromise;
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): ContainerResourcePromise;
     excludeFromMcp(): ContainerResourcePromise;
@@ -8199,9 +8287,9 @@ export interface ContainerResourcePromise extends PromiseLike<ContainerResource>
     withStatus(status: TestResourceStatus): ContainerResourcePromise;
     withNestedConfig(config: TestNestedDto): ContainerResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ContainerResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerResourcePromise;
     withEndpoints(endpoints: string[]): ContainerResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): ContainerResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ContainerResourcePromise;
@@ -8225,7 +8313,8 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** @internal */
-    private async _withContainerRegistryInternal(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ContainerResource> {
+    private async _withContainerRegistryInternal(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ContainerResource> {
+        registry = isPromiseLike(registry) ? await registry : registry;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, registry };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting/withContainerRegistry',
@@ -8235,8 +8324,8 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withContainerRegistryInternal(registry));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._withContainerRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -8253,7 +8342,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     /** Adds a bind mount */
     withBindMount(source: string, target: string, options?: WithBindMountOptions): ContainerResourcePromise {
         const isReadOnly = options?.isReadOnly;
-        return new ContainerResourcePromiseImpl(this._withBindMountInternal(source, target, isReadOnly));
+        return new ContainerResourcePromiseImpl(this._withBindMountInternal(source, target, isReadOnly), this._client);
     }
 
     /** @internal */
@@ -8268,7 +8357,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets the container entrypoint */
     withEntrypoint(entrypoint: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withEntrypointInternal(entrypoint));
+        return new ContainerResourcePromiseImpl(this._withEntrypointInternal(entrypoint), this._client);
     }
 
     /** @internal */
@@ -8283,7 +8372,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets the container image tag */
     withImageTag(tag: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withImageTagInternal(tag));
+        return new ContainerResourcePromiseImpl(this._withImageTagInternal(tag), this._client);
     }
 
     /** @internal */
@@ -8298,7 +8387,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets the container image registry */
     withImageRegistry(registry: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withImageRegistryInternal(registry));
+        return new ContainerResourcePromiseImpl(this._withImageRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -8315,7 +8404,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     /** Sets the container image */
     withImage(image: string, options?: WithImageOptions): ContainerResourcePromise {
         const tag = options?.tag;
-        return new ContainerResourcePromiseImpl(this._withImageInternal(image, tag));
+        return new ContainerResourcePromiseImpl(this._withImageInternal(image, tag), this._client);
     }
 
     /** @internal */
@@ -8330,7 +8419,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets the image SHA256 digest */
     withImageSHA256(sha256: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withImageSHA256Internal(sha256));
+        return new ContainerResourcePromiseImpl(this._withImageSHA256Internal(sha256), this._client);
     }
 
     /** @internal */
@@ -8345,7 +8434,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Adds runtime arguments for the container */
     withContainerRuntimeArgs(args: string[]): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withContainerRuntimeArgsInternal(args));
+        return new ContainerResourcePromiseImpl(this._withContainerRuntimeArgsInternal(args), this._client);
     }
 
     /** @internal */
@@ -8360,7 +8449,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets the lifetime behavior of the container resource */
     withLifetime(lifetime: ContainerLifetime): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withLifetimeInternal(lifetime));
+        return new ContainerResourcePromiseImpl(this._withLifetimeInternal(lifetime), this._client);
     }
 
     /** @internal */
@@ -8375,7 +8464,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets the container image pull policy */
     withImagePullPolicy(pullPolicy: ImagePullPolicy): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withImagePullPolicyInternal(pullPolicy));
+        return new ContainerResourcePromiseImpl(this._withImagePullPolicyInternal(pullPolicy), this._client);
     }
 
     /** @internal */
@@ -8390,7 +8479,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Configures the resource to be published as a container */
     publishAsContainer(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._publishAsContainerInternal());
+        return new ContainerResourcePromiseImpl(this._publishAsContainerInternal(), this._client);
     }
 
     /** @internal */
@@ -8409,7 +8498,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     withDockerfile(contextPath: string, options?: WithDockerfileOptions): ContainerResourcePromise {
         const dockerfilePath = options?.dockerfilePath;
         const stage = options?.stage;
-        return new ContainerResourcePromiseImpl(this._withDockerfileInternal(contextPath, dockerfilePath, stage));
+        return new ContainerResourcePromiseImpl(this._withDockerfileInternal(contextPath, dockerfilePath, stage), this._client);
     }
 
     /** @internal */
@@ -8424,11 +8513,12 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets the container name */
     withContainerName(name: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withContainerNameInternal(name));
+        return new ContainerResourcePromiseImpl(this._withContainerNameInternal(name), this._client);
     }
 
     /** @internal */
-    private async _withBuildArgInternal(name: string, value: ParameterResource): Promise<ContainerResource> {
+    private async _withBuildArgInternal(name: string, value: Awaitable<ParameterResource>): Promise<ContainerResource> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting/withParameterBuildArg',
@@ -8438,12 +8528,13 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Adds a build argument from a parameter resource */
-    withBuildArg(name: string, value: ParameterResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withBuildArgInternal(name, value));
+    withBuildArg(name: string, value: Awaitable<ParameterResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._withBuildArgInternal(name, value), this._client);
     }
 
     /** @internal */
-    private async _withBuildSecretInternal(name: string, value: ParameterResource): Promise<ContainerResource> {
+    private async _withBuildSecretInternal(name: string, value: Awaitable<ParameterResource>): Promise<ContainerResource> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting/withParameterBuildSecret',
@@ -8453,8 +8544,8 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Adds a build secret from a parameter resource */
-    withBuildSecret(name: string, value: ParameterResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withBuildSecretInternal(name, value));
+    withBuildSecret(name: string, value: Awaitable<ParameterResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._withBuildSecretInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -8469,7 +8560,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Configures endpoint proxy support */
     withEndpointProxySupport(proxyEnabled: boolean): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withEndpointProxySupportInternal(proxyEnabled));
+        return new ContainerResourcePromiseImpl(this._withEndpointProxySupportInternal(proxyEnabled), this._client);
     }
 
     /** @internal */
@@ -8488,7 +8579,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ContainerResourcePromise {
         const buildImage = options?.buildImage;
         const runtimeImage = options?.runtimeImage;
-        return new ContainerResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage));
+        return new ContainerResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage), this._client);
     }
 
     /** @internal */
@@ -8503,7 +8594,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Adds a network alias for the container */
     withContainerNetworkAlias(alias: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withContainerNetworkAliasInternal(alias));
+        return new ContainerResourcePromiseImpl(this._withContainerNetworkAliasInternal(alias), this._client);
     }
 
     /** @internal */
@@ -8522,7 +8613,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     withMcpServer(options?: WithMcpServerOptions): ContainerResourcePromise {
         const path = options?.path;
         const endpointName = options?.endpointName;
-        return new ContainerResourcePromiseImpl(this._withMcpServerInternal(path, endpointName));
+        return new ContainerResourcePromiseImpl(this._withMcpServerInternal(path, endpointName), this._client);
     }
 
     /** @internal */
@@ -8537,7 +8628,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withOtlpExporterInternal());
+        return new ContainerResourcePromiseImpl(this._withOtlpExporterInternal(), this._client);
     }
 
     /** @internal */
@@ -8552,7 +8643,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withOtlpExporterProtocolInternal(protocol));
+        return new ContainerResourcePromiseImpl(this._withOtlpExporterProtocolInternal(protocol), this._client);
     }
 
     /** @internal */
@@ -8567,7 +8658,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Publishes the resource as a connection string */
     publishAsConnectionString(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._publishAsConnectionStringInternal());
+        return new ContainerResourcePromiseImpl(this._publishAsConnectionStringInternal(), this._client);
     }
 
     /** @internal */
@@ -8584,11 +8675,12 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ContainerResourcePromise {
         const helpLink = options?.helpLink;
-        return new ContainerResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink));
+        return new ContainerResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): Promise<ContainerResource> {
+    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): Promise<ContainerResource> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting/withEnvironment',
@@ -8598,8 +8690,8 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withEnvironmentInternal(name, value));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._withEnvironmentInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -8617,7 +8709,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withEnvironmentExpressionInternal(name, value));
+        return new ContainerResourcePromiseImpl(this._withEnvironmentExpressionInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -8637,11 +8729,12 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withEnvironmentCallbackInternal(callback));
+        return new ContainerResourcePromiseImpl(this._withEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentEndpointInternal(name: string, endpointReference: EndpointReference): Promise<ContainerResource> {
+    private async _withEnvironmentEndpointInternal(name: string, endpointReference: Awaitable<EndpointReference>): Promise<ContainerResource> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, endpointReference };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting/withEnvironmentEndpoint',
@@ -8654,12 +8747,13 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentParameterInternal(name: string, parameter: ParameterResource): Promise<ContainerResource> {
+    private async _withEnvironmentParameterInternal(name: string, parameter: Awaitable<ParameterResource>): Promise<ContainerResource> {
+        parameter = isPromiseLike(parameter) ? await parameter : parameter;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, parameter };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting/withEnvironmentParameter',
@@ -8672,12 +8766,13 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withEnvironmentParameterInternal(name, parameter));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._withEnvironmentParameterInternal(name, parameter), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ContainerResource> {
+    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ContainerResource> {
+        resource = isPromiseLike(resource) ? await resource : resource;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, envVarName, resource };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting/withEnvironmentConnectionString',
@@ -8690,8 +8785,8 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource), this._client);
     }
 
     /** @internal */
@@ -8706,7 +8801,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Adds arguments */
     withArgs(args: string[]): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withArgsInternal(args));
+        return new ContainerResourcePromiseImpl(this._withArgsInternal(args), this._client);
     }
 
     /** @internal */
@@ -8726,11 +8821,12 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withArgsCallbackInternal(callback));
+        return new ContainerResourcePromiseImpl(this._withArgsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withReferenceInternal(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, connectionName?: string, optional?: boolean, name?: string): Promise<ContainerResource> {
+    private async _withReferenceInternal(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, connectionName?: string, optional?: boolean, name?: string): Promise<ContainerResource> {
+        source = isPromiseLike(source) ? await source : source;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, source };
         if (connectionName !== undefined) rpcArgs.connectionName = connectionName;
         if (optional !== undefined) rpcArgs.optional = optional;
@@ -8743,11 +8839,11 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): ContainerResourcePromise {
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): ContainerResourcePromise {
         const connectionName = options?.connectionName;
         const optional = options?.optional;
         const name = options?.name;
-        return new ContainerResourcePromiseImpl(this._withReferenceInternal(source, connectionName, optional, name));
+        return new ContainerResourcePromiseImpl(this._withReferenceInternal(source, connectionName, optional, name), this._client);
     }
 
     /** @internal */
@@ -8762,11 +8858,12 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withReferenceUriInternal(name, uri));
+        return new ContainerResourcePromiseImpl(this._withReferenceUriInternal(name, uri), this._client);
     }
 
     /** @internal */
-    private async _withReferenceExternalServiceInternal(externalService: ExternalServiceResource): Promise<ContainerResource> {
+    private async _withReferenceExternalServiceInternal(externalService: Awaitable<ExternalServiceResource>): Promise<ContainerResource> {
+        externalService = isPromiseLike(externalService) ? await externalService : externalService;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, externalService };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting/withReferenceExternalService',
@@ -8776,12 +8873,13 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withReferenceExternalServiceInternal(externalService));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._withReferenceExternalServiceInternal(externalService), this._client);
     }
 
     /** @internal */
-    private async _withReferenceEndpointInternal(endpointReference: EndpointReference): Promise<ContainerResource> {
+    private async _withReferenceEndpointInternal(endpointReference: Awaitable<EndpointReference>): Promise<ContainerResource> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, endpointReference };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting/withReferenceEndpoint',
@@ -8791,8 +8889,8 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withReferenceEndpointInternal(endpointReference));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._withReferenceEndpointInternal(endpointReference), this._client);
     }
 
     /** @internal */
@@ -8823,7 +8921,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
         const isProxied = options?.isProxied;
         const isExternal = options?.isExternal;
         const protocol = options?.protocol;
-        return new ContainerResourcePromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol));
+        return new ContainerResourcePromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol), this._client);
     }
 
     /** @internal */
@@ -8848,7 +8946,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new ContainerResourcePromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied));
+        return new ContainerResourcePromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -8873,7 +8971,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new ContainerResourcePromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied));
+        return new ContainerResourcePromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -8888,7 +8986,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withExternalHttpEndpointsInternal());
+        return new ContainerResourcePromiseImpl(this._withExternalHttpEndpointsInternal(), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -8912,7 +9010,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._asHttp2ServiceInternal());
+        return new ContainerResourcePromiseImpl(this._asHttp2ServiceInternal(), this._client);
     }
 
     /** @internal */
@@ -8932,7 +9030,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withUrlsCallbackInternal(callback));
+        return new ContainerResourcePromiseImpl(this._withUrlsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -8949,7 +9047,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): ContainerResourcePromise {
         const displayText = options?.displayText;
-        return new ContainerResourcePromiseImpl(this._withUrlInternal(url, displayText));
+        return new ContainerResourcePromiseImpl(this._withUrlInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -8966,7 +9064,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ContainerResourcePromise {
         const displayText = options?.displayText;
-        return new ContainerResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText));
+        return new ContainerResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -8985,7 +9083,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback));
+        return new ContainerResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -9005,7 +9103,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback));
+        return new ContainerResourcePromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -9020,11 +9118,12 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._excludeFromManifestInternal());
+        return new ContainerResourcePromiseImpl(this._excludeFromManifestInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ContainerResource> {
+    private async _waitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ContainerResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting/waitForResource',
@@ -9034,12 +9133,13 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._waitForInternal(dependency));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._waitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<ContainerResource> {
+    private async _waitForWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<ContainerResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting/waitForWithBehavior',
@@ -9049,12 +9149,13 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
-    private async _waitForStartInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ContainerResource> {
+    private async _waitForStartInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ContainerResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting/waitForResourceStart',
@@ -9064,12 +9165,13 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._waitForStartInternal(dependency));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._waitForStartInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForStartWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<ContainerResource> {
+    private async _waitForStartWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<ContainerResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting/waitForStartWithBehavior',
@@ -9079,8 +9181,8 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
@@ -9095,11 +9197,12 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withExplicitStartInternal());
+        return new ContainerResourcePromiseImpl(this._withExplicitStartInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForCompletionInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, exitCode?: number): Promise<ContainerResource> {
+    private async _waitForCompletionInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, exitCode?: number): Promise<ContainerResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         if (exitCode !== undefined) rpcArgs.exitCode = exitCode;
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
@@ -9110,9 +9213,9 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ContainerResourcePromise {
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ContainerResourcePromise {
         const exitCode = options?.exitCode;
-        return new ContainerResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode));
+        return new ContainerResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode), this._client);
     }
 
     /** @internal */
@@ -9127,7 +9230,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Adds a health check by key */
     withHealthCheck(key: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withHealthCheckInternal(key));
+        return new ContainerResourcePromiseImpl(this._withHealthCheckInternal(key), this._client);
     }
 
     /** @internal */
@@ -9148,7 +9251,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
         const path = options?.path;
         const statusCode = options?.statusCode;
         const endpointName = options?.endpointName;
-        return new ContainerResourcePromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName));
+        return new ContainerResourcePromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName), this._client);
     }
 
     /** @internal */
@@ -9170,7 +9273,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ContainerResourcePromise {
         const commandOptions = options?.commandOptions;
-        return new ContainerResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions));
+        return new ContainerResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions), this._client);
     }
 
     /** @internal */
@@ -9185,7 +9288,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withDeveloperCertificateTrustInternal(trust));
+        return new ContainerResourcePromiseImpl(this._withDeveloperCertificateTrustInternal(trust), this._client);
     }
 
     /** @internal */
@@ -9200,11 +9303,12 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withCertificateTrustScopeInternal(scope));
+        return new ContainerResourcePromiseImpl(this._withCertificateTrustScopeInternal(scope), this._client);
     }
 
     /** @internal */
-    private async _withHttpsDeveloperCertificateInternal(password?: ParameterResource): Promise<ContainerResource> {
+    private async _withHttpsDeveloperCertificateInternal(password?: Awaitable<ParameterResource>): Promise<ContainerResource> {
+        password = isPromiseLike(password) ? await password : password;
         const rpcArgs: Record<string, unknown> = { builder: this._handle };
         if (password !== undefined) rpcArgs.password = password;
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
@@ -9216,8 +9320,8 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): ContainerResourcePromise {
-        const password = options?.password;
-        return new ContainerResourcePromiseImpl(this._withHttpsDeveloperCertificateInternal(password));
+        let password = options?.password;
+        return new ContainerResourcePromiseImpl(this._withHttpsDeveloperCertificateInternal(password), this._client);
     }
 
     /** @internal */
@@ -9232,11 +9336,12 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withoutHttpsCertificateInternal());
+        return new ContainerResourcePromiseImpl(this._withoutHttpsCertificateInternal(), this._client);
     }
 
     /** @internal */
-    private async _withParentRelationshipInternal(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ContainerResource> {
+    private async _withParentRelationshipInternal(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ContainerResource> {
+        parent = isPromiseLike(parent) ? await parent : parent;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, parent };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting/withBuilderParentRelationship',
@@ -9246,12 +9351,13 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withParentRelationshipInternal(parent));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._withParentRelationshipInternal(parent), this._client);
     }
 
     /** @internal */
-    private async _withChildRelationshipInternal(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ContainerResource> {
+    private async _withChildRelationshipInternal(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ContainerResource> {
+        child = isPromiseLike(child) ? await child : child;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, child };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting/withBuilderChildRelationship',
@@ -9261,8 +9367,8 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withChildRelationshipInternal(child));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._withChildRelationshipInternal(child), this._client);
     }
 
     /** @internal */
@@ -9279,7 +9385,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): ContainerResourcePromise {
         const iconVariant = options?.iconVariant;
-        return new ContainerResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant));
+        return new ContainerResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant), this._client);
     }
 
     /** @internal */
@@ -9308,7 +9414,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
         const failureThreshold = options?.failureThreshold;
         const successThreshold = options?.successThreshold;
         const endpointName = options?.endpointName;
-        return new ContainerResourcePromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName));
+        return new ContainerResourcePromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName), this._client);
     }
 
     /** @internal */
@@ -9323,7 +9429,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._excludeFromMcpInternal());
+        return new ContainerResourcePromiseImpl(this._excludeFromMcpInternal(), this._client);
     }
 
     /** @internal */
@@ -9338,7 +9444,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName));
+        return new ContainerResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName), this._client);
     }
 
     /** @internal */
@@ -9353,7 +9459,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag));
+        return new ContainerResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag), this._client);
     }
 
     /** @internal */
@@ -9381,7 +9487,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
         const requiredBy = options?.requiredBy;
         const tags = options?.tags;
         const description = options?.description;
-        return new ContainerResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description));
+        return new ContainerResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description), this._client);
     }
 
     /** @internal */
@@ -9401,7 +9507,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withPipelineConfigurationInternal(callback));
+        return new ContainerResourcePromiseImpl(this._withPipelineConfigurationInternal(callback), this._client);
     }
 
     /** @internal */
@@ -9420,7 +9526,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     withVolume(target: string, options?: WithVolumeOptions): ContainerResourcePromise {
         const name = options?.name;
         const isReadOnly = options?.isReadOnly;
-        return new ContainerResourcePromiseImpl(this._withVolumeInternal(target, name, isReadOnly));
+        return new ContainerResourcePromiseImpl(this._withVolumeInternal(target, name, isReadOnly), this._client);
     }
 
     /** Gets the resource name */
@@ -9449,7 +9555,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback));
+        return new ContainerResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -9469,7 +9575,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._onResourceStoppedInternal(callback));
+        return new ContainerResourcePromiseImpl(this._onResourceStoppedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -9489,7 +9595,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._onInitializeResourceInternal(callback));
+        return new ContainerResourcePromiseImpl(this._onInitializeResourceInternal(callback), this._client);
     }
 
     /** @internal */
@@ -9509,7 +9615,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._onResourceEndpointsAllocatedInternal(callback));
+        return new ContainerResourcePromiseImpl(this._onResourceEndpointsAllocatedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -9529,7 +9635,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._onResourceReadyInternal(callback));
+        return new ContainerResourcePromiseImpl(this._onResourceReadyInternal(callback), this._client);
     }
 
     /** @internal */
@@ -9548,7 +9654,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     withOptionalString(options?: WithOptionalStringOptions): ContainerResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new ContainerResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new ContainerResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -9563,7 +9669,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withConfigInternal(config));
+        return new ContainerResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -9583,7 +9689,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback));
+        return new ContainerResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -9598,7 +9704,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new ContainerResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -9613,7 +9719,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new ContainerResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -9628,7 +9734,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new ContainerResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -9650,7 +9756,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ContainerResourcePromise {
         const callback = options?.callback;
-        return new ContainerResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new ContainerResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -9665,7 +9771,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withStatusInternal(status));
+        return new ContainerResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -9680,7 +9786,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new ContainerResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -9700,11 +9806,12 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new ContainerResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ContainerResource> {
+    private async _testWaitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ContainerResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -9714,12 +9821,13 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ContainerResource> {
+    private async _withDependencyInternal(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ContainerResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -9729,12 +9837,13 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ContainerResource> {
+    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ContainerResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ContainerResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -9744,8 +9853,8 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -9760,7 +9869,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new ContainerResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -9775,7 +9884,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables));
+        return new ContainerResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables), this._client);
     }
 
     /** @internal */
@@ -9794,7 +9903,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new ContainerResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** @internal */
@@ -9809,7 +9918,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new ContainerResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -9824,7 +9933,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new ContainerResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -9839,7 +9948,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new ContainerResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -9854,7 +9963,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new ContainerResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -9873,7 +9982,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ContainerResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ContainerResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new ContainerResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -9892,7 +10001,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ContainerResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ContainerResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new ContainerResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -9907,7 +10016,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new ContainerResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -9922,7 +10031,7 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new ContainerResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -9933,7 +10042,9 @@ class ContainerResourceImpl extends ResourceBuilderBase<ContainerResourceHandle>
  * await builder.addSomething().withX().withY();
  */
 class ContainerResourcePromiseImpl implements ContainerResourcePromise {
-    constructor(private _promise: Promise<ContainerResource>) {}
+    constructor(private _promise: Promise<ContainerResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ContainerResource, TResult2 = never>(
         onfulfilled?: ((value: ContainerResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -9943,123 +10054,123 @@ class ContainerResourcePromiseImpl implements ContainerResourcePromise {
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)), this._client);
     }
 
     /** Adds a bind mount */
     withBindMount(source: string, target: string, options?: WithBindMountOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withBindMount(source, target, options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withBindMount(source, target, options)), this._client);
     }
 
     /** Sets the container entrypoint */
     withEntrypoint(entrypoint: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEntrypoint(entrypoint)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEntrypoint(entrypoint)), this._client);
     }
 
     /** Sets the container image tag */
     withImageTag(tag: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withImageTag(tag)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withImageTag(tag)), this._client);
     }
 
     /** Sets the container image registry */
     withImageRegistry(registry: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withImageRegistry(registry)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withImageRegistry(registry)), this._client);
     }
 
     /** Sets the container image */
     withImage(image: string, options?: WithImageOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withImage(image, options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withImage(image, options)), this._client);
     }
 
     /** Sets the image SHA256 digest */
     withImageSHA256(sha256: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withImageSHA256(sha256)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withImageSHA256(sha256)), this._client);
     }
 
     /** Adds runtime arguments for the container */
     withContainerRuntimeArgs(args: string[]): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withContainerRuntimeArgs(args)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withContainerRuntimeArgs(args)), this._client);
     }
 
     /** Sets the lifetime behavior of the container resource */
     withLifetime(lifetime: ContainerLifetime): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withLifetime(lifetime)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withLifetime(lifetime)), this._client);
     }
 
     /** Sets the container image pull policy */
     withImagePullPolicy(pullPolicy: ImagePullPolicy): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withImagePullPolicy(pullPolicy)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withImagePullPolicy(pullPolicy)), this._client);
     }
 
     /** Configures the resource to be published as a container */
     publishAsContainer(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.publishAsContainer()));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.publishAsContainer()), this._client);
     }
 
     /** Configures the resource to use a Dockerfile */
     withDockerfile(contextPath: string, options?: WithDockerfileOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withDockerfile(contextPath, options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withDockerfile(contextPath, options)), this._client);
     }
 
     /** Sets the container name */
     withContainerName(name: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withContainerName(name)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withContainerName(name)), this._client);
     }
 
     /** Adds a build argument from a parameter resource */
-    withBuildArg(name: string, value: ParameterResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withBuildArg(name, value)));
+    withBuildArg(name: string, value: Awaitable<ParameterResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withBuildArg(name, value)), this._client);
     }
 
     /** Adds a build secret from a parameter resource */
-    withBuildSecret(name: string, value: ParameterResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withBuildSecret(name, value)));
+    withBuildSecret(name: string, value: Awaitable<ParameterResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withBuildSecret(name, value)), this._client);
     }
 
     /** Configures endpoint proxy support */
     withEndpointProxySupport(proxyEnabled: boolean): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEndpointProxySupport(proxyEnabled)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEndpointProxySupport(proxyEnabled)), this._client);
     }
 
     /** Sets the base image for a Dockerfile build */
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)), this._client);
     }
 
     /** Adds a network alias for the container */
     withContainerNetworkAlias(alias: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withContainerNetworkAlias(alias)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withContainerNetworkAlias(alias)), this._client);
     }
 
     /** Configures an MCP server endpoint on the resource */
     withMcpServer(options?: WithMcpServerOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMcpServer(options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMcpServer(options)), this._client);
     }
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporter()));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporter()), this._client);
     }
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)), this._client);
     }
 
     /** Publishes the resource as a connection string */
     publishAsConnectionString(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.publishAsConnectionString()));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.publishAsConnectionString()), this._client);
     }
 
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)), this._client);
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)), this._client);
     }
 
     /**
@@ -10067,86 +10178,86 @@ class ContainerResourcePromiseImpl implements ContainerResourcePromise {
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)), this._client);
     }
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)), this._client);
     }
 
     /**
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)), this._client);
     }
 
     /**
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)), this._client);
     }
 
     /**
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)), this._client);
     }
 
     /** Adds arguments */
     withArgs(args: string[]): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withArgs(args)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withArgs(args)), this._client);
     }
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)), this._client);
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withReference(source, options)));
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withReference(source, options)), this._client);
     }
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)), this._client);
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)), this._client);
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)), this._client);
     }
 
     /** Adds a network endpoint */
     withEndpoint(options?: WithEndpointOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEndpoint(options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEndpoint(options)), this._client);
     }
 
     /** Adds an HTTP endpoint */
     withHttpEndpoint(options?: WithHttpEndpointOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)), this._client);
     }
 
     /** Adds an HTTPS endpoint */
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)), this._client);
     }
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -10156,152 +10267,152 @@ class ContainerResourcePromiseImpl implements ContainerResourcePromise {
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.asHttp2Service()));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.asHttp2Service()), this._client);
     }
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)), this._client);
     }
 
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)), this._client);
     }
 
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)), this._client);
     }
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)), this._client);
     }
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)), this._client);
     }
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()), this._client);
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)), this._client);
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)), this._client);
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()), this._client);
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)));
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)), this._client);
     }
 
     /** Adds a health check by key */
     withHealthCheck(key: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)), this._client);
     }
 
     /** Adds an HTTP health check */
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)), this._client);
     }
 
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)), this._client);
     }
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)), this._client);
     }
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)), this._client);
     }
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)), this._client);
     }
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()), this._client);
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)), this._client);
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)), this._client);
     }
 
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)), this._client);
     }
 
     /** Adds an HTTP health probe to the resource */
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)), this._client);
     }
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()), this._client);
     }
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)), this._client);
     }
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)), this._client);
     }
 
     /** Adds a pipeline step to the resource */
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)), this._client);
     }
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)), this._client);
     }
 
     /** Adds a volume */
     withVolume(target: string, options?: WithVolumeOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withVolume(target, options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withVolume(target, options)), this._client);
     }
 
     /** Gets the resource name */
@@ -10311,147 +10422,147 @@ class ContainerResourcePromiseImpl implements ContainerResourcePromise {
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)), this._client);
     }
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)), this._client);
     }
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)), this._client);
     }
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)), this._client);
     }
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)), this._client);
     }
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ContainerResourcePromise {
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)), this._client);
     }
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ContainerResourcePromise {
-        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new ContainerResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -10462,7 +10573,7 @@ class ContainerResourcePromiseImpl implements ContainerResourcePromise {
 
 export interface CSharpAppResource {
     toJSON(): MarshalledHandle;
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): CSharpAppResourcePromise;
     withMcpServer(options?: WithMcpServerOptions): CSharpAppResourcePromise;
     withOtlpExporter(): CSharpAppResourcePromise;
@@ -10471,18 +10582,18 @@ export interface CSharpAppResource {
     disableForwardedHeaders(): CSharpAppResourcePromise;
     publishAsDockerFile(options?: PublishAsDockerFileOptions): CSharpAppResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): CSharpAppResourcePromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): CSharpAppResourcePromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): CSharpAppResourcePromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): CSharpAppResourcePromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): CSharpAppResourcePromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): CSharpAppResourcePromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): CSharpAppResourcePromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): CSharpAppResourcePromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): CSharpAppResourcePromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): CSharpAppResourcePromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): CSharpAppResourcePromise;
     withArgs(args: string[]): CSharpAppResourcePromise;
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): CSharpAppResourcePromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): CSharpAppResourcePromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): CSharpAppResourcePromise;
     withReferenceUri(name: string, uri: string): CSharpAppResourcePromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): CSharpAppResourcePromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): CSharpAppResourcePromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): CSharpAppResourcePromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): CSharpAppResourcePromise;
     withEndpoint(options?: WithEndpointOptions): CSharpAppResourcePromise;
     withHttpEndpoint(options?: WithHttpEndpointOptions): CSharpAppResourcePromise;
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): CSharpAppResourcePromise;
@@ -10494,14 +10605,14 @@ export interface CSharpAppResource {
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): CSharpAppResourcePromise;
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): CSharpAppResourcePromise;
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): CSharpAppResourcePromise;
-    publishWithContainerFiles(source: ResourceWithContainerFiles, destinationPath: string): CSharpAppResourcePromise;
+    publishWithContainerFiles(source: Awaitable<ResourceWithContainerFiles>, destinationPath: string): CSharpAppResourcePromise;
     excludeFromManifest(): CSharpAppResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): CSharpAppResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): CSharpAppResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): CSharpAppResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): CSharpAppResourcePromise;
     withExplicitStart(): CSharpAppResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): CSharpAppResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): CSharpAppResourcePromise;
     withHealthCheck(key: string): CSharpAppResourcePromise;
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): CSharpAppResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): CSharpAppResourcePromise;
@@ -10509,8 +10620,8 @@ export interface CSharpAppResource {
     withCertificateTrustScope(scope: CertificateTrustScope): CSharpAppResourcePromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): CSharpAppResourcePromise;
     withoutHttpsCertificate(): CSharpAppResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): CSharpAppResourcePromise;
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): CSharpAppResourcePromise;
     excludeFromMcp(): CSharpAppResourcePromise;
@@ -10534,9 +10645,9 @@ export interface CSharpAppResource {
     withStatus(status: TestResourceStatus): CSharpAppResourcePromise;
     withNestedConfig(config: TestNestedDto): CSharpAppResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): CSharpAppResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): CSharpAppResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): CSharpAppResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): CSharpAppResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): CSharpAppResourcePromise;
     withEndpoints(endpoints: string[]): CSharpAppResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): CSharpAppResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): CSharpAppResourcePromise;
@@ -10551,7 +10662,7 @@ export interface CSharpAppResource {
 }
 
 export interface CSharpAppResourcePromise extends PromiseLike<CSharpAppResource> {
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): CSharpAppResourcePromise;
     withMcpServer(options?: WithMcpServerOptions): CSharpAppResourcePromise;
     withOtlpExporter(): CSharpAppResourcePromise;
@@ -10560,18 +10671,18 @@ export interface CSharpAppResourcePromise extends PromiseLike<CSharpAppResource>
     disableForwardedHeaders(): CSharpAppResourcePromise;
     publishAsDockerFile(options?: PublishAsDockerFileOptions): CSharpAppResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): CSharpAppResourcePromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): CSharpAppResourcePromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): CSharpAppResourcePromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): CSharpAppResourcePromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): CSharpAppResourcePromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): CSharpAppResourcePromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): CSharpAppResourcePromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): CSharpAppResourcePromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): CSharpAppResourcePromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): CSharpAppResourcePromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): CSharpAppResourcePromise;
     withArgs(args: string[]): CSharpAppResourcePromise;
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): CSharpAppResourcePromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): CSharpAppResourcePromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): CSharpAppResourcePromise;
     withReferenceUri(name: string, uri: string): CSharpAppResourcePromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): CSharpAppResourcePromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): CSharpAppResourcePromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): CSharpAppResourcePromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): CSharpAppResourcePromise;
     withEndpoint(options?: WithEndpointOptions): CSharpAppResourcePromise;
     withHttpEndpoint(options?: WithHttpEndpointOptions): CSharpAppResourcePromise;
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): CSharpAppResourcePromise;
@@ -10583,14 +10694,14 @@ export interface CSharpAppResourcePromise extends PromiseLike<CSharpAppResource>
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): CSharpAppResourcePromise;
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): CSharpAppResourcePromise;
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): CSharpAppResourcePromise;
-    publishWithContainerFiles(source: ResourceWithContainerFiles, destinationPath: string): CSharpAppResourcePromise;
+    publishWithContainerFiles(source: Awaitable<ResourceWithContainerFiles>, destinationPath: string): CSharpAppResourcePromise;
     excludeFromManifest(): CSharpAppResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): CSharpAppResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): CSharpAppResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): CSharpAppResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): CSharpAppResourcePromise;
     withExplicitStart(): CSharpAppResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): CSharpAppResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): CSharpAppResourcePromise;
     withHealthCheck(key: string): CSharpAppResourcePromise;
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): CSharpAppResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): CSharpAppResourcePromise;
@@ -10598,8 +10709,8 @@ export interface CSharpAppResourcePromise extends PromiseLike<CSharpAppResource>
     withCertificateTrustScope(scope: CertificateTrustScope): CSharpAppResourcePromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): CSharpAppResourcePromise;
     withoutHttpsCertificate(): CSharpAppResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): CSharpAppResourcePromise;
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): CSharpAppResourcePromise;
     excludeFromMcp(): CSharpAppResourcePromise;
@@ -10623,9 +10734,9 @@ export interface CSharpAppResourcePromise extends PromiseLike<CSharpAppResource>
     withStatus(status: TestResourceStatus): CSharpAppResourcePromise;
     withNestedConfig(config: TestNestedDto): CSharpAppResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): CSharpAppResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): CSharpAppResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): CSharpAppResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): CSharpAppResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): CSharpAppResourcePromise;
     withEndpoints(endpoints: string[]): CSharpAppResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): CSharpAppResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): CSharpAppResourcePromise;
@@ -10649,7 +10760,8 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** @internal */
-    private async _withContainerRegistryInternal(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<CSharpAppResource> {
+    private async _withContainerRegistryInternal(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<CSharpAppResource> {
+        registry = isPromiseLike(registry) ? await registry : registry;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, registry };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting/withContainerRegistry',
@@ -10659,8 +10771,8 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withContainerRegistryInternal(registry));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._withContainerRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -10679,7 +10791,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): CSharpAppResourcePromise {
         const buildImage = options?.buildImage;
         const runtimeImage = options?.runtimeImage;
-        return new CSharpAppResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage));
+        return new CSharpAppResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage), this._client);
     }
 
     /** @internal */
@@ -10698,7 +10810,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     withMcpServer(options?: WithMcpServerOptions): CSharpAppResourcePromise {
         const path = options?.path;
         const endpointName = options?.endpointName;
-        return new CSharpAppResourcePromiseImpl(this._withMcpServerInternal(path, endpointName));
+        return new CSharpAppResourcePromiseImpl(this._withMcpServerInternal(path, endpointName), this._client);
     }
 
     /** @internal */
@@ -10713,7 +10825,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withOtlpExporterInternal());
+        return new CSharpAppResourcePromiseImpl(this._withOtlpExporterInternal(), this._client);
     }
 
     /** @internal */
@@ -10728,7 +10840,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withOtlpExporterProtocolInternal(protocol));
+        return new CSharpAppResourcePromiseImpl(this._withOtlpExporterProtocolInternal(protocol), this._client);
     }
 
     /** @internal */
@@ -10743,7 +10855,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Sets the number of replicas */
     withReplicas(replicas: number): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withReplicasInternal(replicas));
+        return new CSharpAppResourcePromiseImpl(this._withReplicasInternal(replicas), this._client);
     }
 
     /** @internal */
@@ -10758,7 +10870,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Disables forwarded headers for the project */
     disableForwardedHeaders(): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._disableForwardedHeadersInternal());
+        return new CSharpAppResourcePromiseImpl(this._disableForwardedHeadersInternal(), this._client);
     }
 
     /** @internal */
@@ -10780,7 +10892,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     /** Publishes a project as a Docker file with optional container configuration */
     publishAsDockerFile(options?: PublishAsDockerFileOptions): CSharpAppResourcePromise {
         const configure = options?.configure;
-        return new CSharpAppResourcePromiseImpl(this._publishAsDockerFileInternal(configure));
+        return new CSharpAppResourcePromiseImpl(this._publishAsDockerFileInternal(configure), this._client);
     }
 
     /** @internal */
@@ -10797,11 +10909,12 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): CSharpAppResourcePromise {
         const helpLink = options?.helpLink;
-        return new CSharpAppResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink));
+        return new CSharpAppResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): Promise<CSharpAppResource> {
+    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): Promise<CSharpAppResource> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting/withEnvironment',
@@ -10811,8 +10924,8 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withEnvironmentInternal(name, value));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._withEnvironmentInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -10830,7 +10943,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withEnvironmentExpressionInternal(name, value));
+        return new CSharpAppResourcePromiseImpl(this._withEnvironmentExpressionInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -10850,11 +10963,12 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withEnvironmentCallbackInternal(callback));
+        return new CSharpAppResourcePromiseImpl(this._withEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentEndpointInternal(name: string, endpointReference: EndpointReference): Promise<CSharpAppResource> {
+    private async _withEnvironmentEndpointInternal(name: string, endpointReference: Awaitable<EndpointReference>): Promise<CSharpAppResource> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, endpointReference };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting/withEnvironmentEndpoint',
@@ -10867,12 +10981,13 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentParameterInternal(name: string, parameter: ParameterResource): Promise<CSharpAppResource> {
+    private async _withEnvironmentParameterInternal(name: string, parameter: Awaitable<ParameterResource>): Promise<CSharpAppResource> {
+        parameter = isPromiseLike(parameter) ? await parameter : parameter;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, parameter };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting/withEnvironmentParameter',
@@ -10885,12 +11000,13 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withEnvironmentParameterInternal(name, parameter));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._withEnvironmentParameterInternal(name, parameter), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<CSharpAppResource> {
+    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<CSharpAppResource> {
+        resource = isPromiseLike(resource) ? await resource : resource;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, envVarName, resource };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting/withEnvironmentConnectionString',
@@ -10903,8 +11019,8 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource), this._client);
     }
 
     /** @internal */
@@ -10919,7 +11035,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Adds arguments */
     withArgs(args: string[]): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withArgsInternal(args));
+        return new CSharpAppResourcePromiseImpl(this._withArgsInternal(args), this._client);
     }
 
     /** @internal */
@@ -10939,11 +11055,12 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withArgsCallbackInternal(callback));
+        return new CSharpAppResourcePromiseImpl(this._withArgsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withReferenceInternal(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, connectionName?: string, optional?: boolean, name?: string): Promise<CSharpAppResource> {
+    private async _withReferenceInternal(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, connectionName?: string, optional?: boolean, name?: string): Promise<CSharpAppResource> {
+        source = isPromiseLike(source) ? await source : source;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, source };
         if (connectionName !== undefined) rpcArgs.connectionName = connectionName;
         if (optional !== undefined) rpcArgs.optional = optional;
@@ -10956,11 +11073,11 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): CSharpAppResourcePromise {
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): CSharpAppResourcePromise {
         const connectionName = options?.connectionName;
         const optional = options?.optional;
         const name = options?.name;
-        return new CSharpAppResourcePromiseImpl(this._withReferenceInternal(source, connectionName, optional, name));
+        return new CSharpAppResourcePromiseImpl(this._withReferenceInternal(source, connectionName, optional, name), this._client);
     }
 
     /** @internal */
@@ -10975,11 +11092,12 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withReferenceUriInternal(name, uri));
+        return new CSharpAppResourcePromiseImpl(this._withReferenceUriInternal(name, uri), this._client);
     }
 
     /** @internal */
-    private async _withReferenceExternalServiceInternal(externalService: ExternalServiceResource): Promise<CSharpAppResource> {
+    private async _withReferenceExternalServiceInternal(externalService: Awaitable<ExternalServiceResource>): Promise<CSharpAppResource> {
+        externalService = isPromiseLike(externalService) ? await externalService : externalService;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, externalService };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting/withReferenceExternalService',
@@ -10989,12 +11107,13 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withReferenceExternalServiceInternal(externalService));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._withReferenceExternalServiceInternal(externalService), this._client);
     }
 
     /** @internal */
-    private async _withReferenceEndpointInternal(endpointReference: EndpointReference): Promise<CSharpAppResource> {
+    private async _withReferenceEndpointInternal(endpointReference: Awaitable<EndpointReference>): Promise<CSharpAppResource> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, endpointReference };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting/withReferenceEndpoint',
@@ -11004,8 +11123,8 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withReferenceEndpointInternal(endpointReference));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._withReferenceEndpointInternal(endpointReference), this._client);
     }
 
     /** @internal */
@@ -11036,7 +11155,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
         const isProxied = options?.isProxied;
         const isExternal = options?.isExternal;
         const protocol = options?.protocol;
-        return new CSharpAppResourcePromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol));
+        return new CSharpAppResourcePromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol), this._client);
     }
 
     /** @internal */
@@ -11061,7 +11180,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new CSharpAppResourcePromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied));
+        return new CSharpAppResourcePromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -11086,7 +11205,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new CSharpAppResourcePromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied));
+        return new CSharpAppResourcePromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -11101,7 +11220,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withExternalHttpEndpointsInternal());
+        return new CSharpAppResourcePromiseImpl(this._withExternalHttpEndpointsInternal(), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -11125,7 +11244,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._asHttp2ServiceInternal());
+        return new CSharpAppResourcePromiseImpl(this._asHttp2ServiceInternal(), this._client);
     }
 
     /** @internal */
@@ -11145,7 +11264,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withUrlsCallbackInternal(callback));
+        return new CSharpAppResourcePromiseImpl(this._withUrlsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -11162,7 +11281,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): CSharpAppResourcePromise {
         const displayText = options?.displayText;
-        return new CSharpAppResourcePromiseImpl(this._withUrlInternal(url, displayText));
+        return new CSharpAppResourcePromiseImpl(this._withUrlInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -11179,7 +11298,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): CSharpAppResourcePromise {
         const displayText = options?.displayText;
-        return new CSharpAppResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText));
+        return new CSharpAppResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -11198,7 +11317,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback));
+        return new CSharpAppResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -11218,11 +11337,12 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback));
+        return new CSharpAppResourcePromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
-    private async _publishWithContainerFilesInternal(source: ResourceWithContainerFiles, destinationPath: string): Promise<CSharpAppResource> {
+    private async _publishWithContainerFilesInternal(source: Awaitable<ResourceWithContainerFiles>, destinationPath: string): Promise<CSharpAppResource> {
+        source = isPromiseLike(source) ? await source : source;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, source, destinationPath };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting/publishWithContainerFilesFromResource',
@@ -11232,8 +11352,8 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** Configures the resource to copy container files from the specified source during publishing */
-    publishWithContainerFiles(source: ResourceWithContainerFiles, destinationPath: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._publishWithContainerFilesInternal(source, destinationPath));
+    publishWithContainerFiles(source: Awaitable<ResourceWithContainerFiles>, destinationPath: string): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._publishWithContainerFilesInternal(source, destinationPath), this._client);
     }
 
     /** @internal */
@@ -11248,11 +11368,12 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._excludeFromManifestInternal());
+        return new CSharpAppResourcePromiseImpl(this._excludeFromManifestInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<CSharpAppResource> {
+    private async _waitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<CSharpAppResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting/waitForResource',
@@ -11262,12 +11383,13 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._waitForInternal(dependency));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._waitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<CSharpAppResource> {
+    private async _waitForWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<CSharpAppResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting/waitForWithBehavior',
@@ -11277,12 +11399,13 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
-    private async _waitForStartInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<CSharpAppResource> {
+    private async _waitForStartInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<CSharpAppResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting/waitForResourceStart',
@@ -11292,12 +11415,13 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._waitForStartInternal(dependency));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._waitForStartInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForStartWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<CSharpAppResource> {
+    private async _waitForStartWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<CSharpAppResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting/waitForStartWithBehavior',
@@ -11307,8 +11431,8 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
@@ -11323,11 +11447,12 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withExplicitStartInternal());
+        return new CSharpAppResourcePromiseImpl(this._withExplicitStartInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForCompletionInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, exitCode?: number): Promise<CSharpAppResource> {
+    private async _waitForCompletionInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, exitCode?: number): Promise<CSharpAppResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         if (exitCode !== undefined) rpcArgs.exitCode = exitCode;
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
@@ -11338,9 +11463,9 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): CSharpAppResourcePromise {
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): CSharpAppResourcePromise {
         const exitCode = options?.exitCode;
-        return new CSharpAppResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode));
+        return new CSharpAppResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode), this._client);
     }
 
     /** @internal */
@@ -11355,7 +11480,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Adds a health check by key */
     withHealthCheck(key: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withHealthCheckInternal(key));
+        return new CSharpAppResourcePromiseImpl(this._withHealthCheckInternal(key), this._client);
     }
 
     /** @internal */
@@ -11376,7 +11501,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
         const path = options?.path;
         const statusCode = options?.statusCode;
         const endpointName = options?.endpointName;
-        return new CSharpAppResourcePromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName));
+        return new CSharpAppResourcePromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName), this._client);
     }
 
     /** @internal */
@@ -11398,7 +11523,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): CSharpAppResourcePromise {
         const commandOptions = options?.commandOptions;
-        return new CSharpAppResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions));
+        return new CSharpAppResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions), this._client);
     }
 
     /** @internal */
@@ -11413,7 +11538,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withDeveloperCertificateTrustInternal(trust));
+        return new CSharpAppResourcePromiseImpl(this._withDeveloperCertificateTrustInternal(trust), this._client);
     }
 
     /** @internal */
@@ -11428,11 +11553,12 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withCertificateTrustScopeInternal(scope));
+        return new CSharpAppResourcePromiseImpl(this._withCertificateTrustScopeInternal(scope), this._client);
     }
 
     /** @internal */
-    private async _withHttpsDeveloperCertificateInternal(password?: ParameterResource): Promise<CSharpAppResource> {
+    private async _withHttpsDeveloperCertificateInternal(password?: Awaitable<ParameterResource>): Promise<CSharpAppResource> {
+        password = isPromiseLike(password) ? await password : password;
         const rpcArgs: Record<string, unknown> = { builder: this._handle };
         if (password !== undefined) rpcArgs.password = password;
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
@@ -11444,8 +11570,8 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): CSharpAppResourcePromise {
-        const password = options?.password;
-        return new CSharpAppResourcePromiseImpl(this._withHttpsDeveloperCertificateInternal(password));
+        let password = options?.password;
+        return new CSharpAppResourcePromiseImpl(this._withHttpsDeveloperCertificateInternal(password), this._client);
     }
 
     /** @internal */
@@ -11460,11 +11586,12 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withoutHttpsCertificateInternal());
+        return new CSharpAppResourcePromiseImpl(this._withoutHttpsCertificateInternal(), this._client);
     }
 
     /** @internal */
-    private async _withParentRelationshipInternal(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<CSharpAppResource> {
+    private async _withParentRelationshipInternal(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<CSharpAppResource> {
+        parent = isPromiseLike(parent) ? await parent : parent;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, parent };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting/withBuilderParentRelationship',
@@ -11474,12 +11601,13 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withParentRelationshipInternal(parent));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._withParentRelationshipInternal(parent), this._client);
     }
 
     /** @internal */
-    private async _withChildRelationshipInternal(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<CSharpAppResource> {
+    private async _withChildRelationshipInternal(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<CSharpAppResource> {
+        child = isPromiseLike(child) ? await child : child;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, child };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting/withBuilderChildRelationship',
@@ -11489,8 +11617,8 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withChildRelationshipInternal(child));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._withChildRelationshipInternal(child), this._client);
     }
 
     /** @internal */
@@ -11507,7 +11635,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): CSharpAppResourcePromise {
         const iconVariant = options?.iconVariant;
-        return new CSharpAppResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant));
+        return new CSharpAppResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant), this._client);
     }
 
     /** @internal */
@@ -11536,7 +11664,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
         const failureThreshold = options?.failureThreshold;
         const successThreshold = options?.successThreshold;
         const endpointName = options?.endpointName;
-        return new CSharpAppResourcePromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName));
+        return new CSharpAppResourcePromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName), this._client);
     }
 
     /** @internal */
@@ -11551,7 +11679,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._excludeFromMcpInternal());
+        return new CSharpAppResourcePromiseImpl(this._excludeFromMcpInternal(), this._client);
     }
 
     /** @internal */
@@ -11566,7 +11694,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName));
+        return new CSharpAppResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName), this._client);
     }
 
     /** @internal */
@@ -11581,7 +11709,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag));
+        return new CSharpAppResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag), this._client);
     }
 
     /** @internal */
@@ -11609,7 +11737,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
         const requiredBy = options?.requiredBy;
         const tags = options?.tags;
         const description = options?.description;
-        return new CSharpAppResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description));
+        return new CSharpAppResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description), this._client);
     }
 
     /** @internal */
@@ -11629,7 +11757,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withPipelineConfigurationInternal(callback));
+        return new CSharpAppResourcePromiseImpl(this._withPipelineConfigurationInternal(callback), this._client);
     }
 
     /** Gets the resource name */
@@ -11658,7 +11786,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback));
+        return new CSharpAppResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -11678,7 +11806,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._onResourceStoppedInternal(callback));
+        return new CSharpAppResourcePromiseImpl(this._onResourceStoppedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -11698,7 +11826,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._onInitializeResourceInternal(callback));
+        return new CSharpAppResourcePromiseImpl(this._onInitializeResourceInternal(callback), this._client);
     }
 
     /** @internal */
@@ -11718,7 +11846,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._onResourceEndpointsAllocatedInternal(callback));
+        return new CSharpAppResourcePromiseImpl(this._onResourceEndpointsAllocatedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -11738,7 +11866,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._onResourceReadyInternal(callback));
+        return new CSharpAppResourcePromiseImpl(this._onResourceReadyInternal(callback), this._client);
     }
 
     /** @internal */
@@ -11757,7 +11885,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     withOptionalString(options?: WithOptionalStringOptions): CSharpAppResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new CSharpAppResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new CSharpAppResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -11772,7 +11900,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withConfigInternal(config));
+        return new CSharpAppResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -11792,7 +11920,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback));
+        return new CSharpAppResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -11807,7 +11935,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new CSharpAppResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -11822,7 +11950,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new CSharpAppResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -11837,7 +11965,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new CSharpAppResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -11859,7 +11987,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): CSharpAppResourcePromise {
         const callback = options?.callback;
-        return new CSharpAppResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new CSharpAppResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -11874,7 +12002,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withStatusInternal(status));
+        return new CSharpAppResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -11889,7 +12017,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new CSharpAppResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -11909,11 +12037,12 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new CSharpAppResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<CSharpAppResource> {
+    private async _testWaitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<CSharpAppResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -11923,12 +12052,13 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<CSharpAppResource> {
+    private async _withDependencyInternal(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<CSharpAppResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -11938,12 +12068,13 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<CSharpAppResource> {
+    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<CSharpAppResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<CSharpAppResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -11953,8 +12084,8 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -11969,7 +12100,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new CSharpAppResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -11984,7 +12115,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables));
+        return new CSharpAppResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables), this._client);
     }
 
     /** @internal */
@@ -12003,7 +12134,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new CSharpAppResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** @internal */
@@ -12018,7 +12149,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new CSharpAppResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -12033,7 +12164,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new CSharpAppResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -12048,7 +12179,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new CSharpAppResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -12063,7 +12194,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new CSharpAppResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -12082,7 +12213,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): CSharpAppResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new CSharpAppResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new CSharpAppResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -12101,7 +12232,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): CSharpAppResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new CSharpAppResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new CSharpAppResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -12116,7 +12247,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new CSharpAppResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -12131,7 +12262,7 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new CSharpAppResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -12142,7 +12273,9 @@ class CSharpAppResourceImpl extends ResourceBuilderBase<CSharpAppResourceHandle>
  * await builder.addSomething().withX().withY();
  */
 class CSharpAppResourcePromiseImpl implements CSharpAppResourcePromise {
-    constructor(private _promise: Promise<CSharpAppResource>) {}
+    constructor(private _promise: Promise<CSharpAppResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = CSharpAppResource, TResult2 = never>(
         onfulfilled?: ((value: CSharpAppResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -12152,53 +12285,53 @@ class CSharpAppResourcePromiseImpl implements CSharpAppResourcePromise {
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)), this._client);
     }
 
     /** Sets the base image for a Dockerfile build */
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)), this._client);
     }
 
     /** Configures an MCP server endpoint on the resource */
     withMcpServer(options?: WithMcpServerOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMcpServer(options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMcpServer(options)), this._client);
     }
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporter()));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporter()), this._client);
     }
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)), this._client);
     }
 
     /** Sets the number of replicas */
     withReplicas(replicas: number): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withReplicas(replicas)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withReplicas(replicas)), this._client);
     }
 
     /** Disables forwarded headers for the project */
     disableForwardedHeaders(): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.disableForwardedHeaders()));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.disableForwardedHeaders()), this._client);
     }
 
     /** Publishes a project as a Docker file with optional container configuration */
     publishAsDockerFile(options?: PublishAsDockerFileOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.publishAsDockerFile(options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.publishAsDockerFile(options)), this._client);
     }
 
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)), this._client);
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)), this._client);
     }
 
     /**
@@ -12206,86 +12339,86 @@ class CSharpAppResourcePromiseImpl implements CSharpAppResourcePromise {
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)), this._client);
     }
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)), this._client);
     }
 
     /**
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)), this._client);
     }
 
     /**
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)), this._client);
     }
 
     /**
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)), this._client);
     }
 
     /** Adds arguments */
     withArgs(args: string[]): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withArgs(args)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withArgs(args)), this._client);
     }
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)), this._client);
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withReference(source, options)));
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withReference(source, options)), this._client);
     }
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)), this._client);
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)), this._client);
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)), this._client);
     }
 
     /** Adds a network endpoint */
     withEndpoint(options?: WithEndpointOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEndpoint(options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEndpoint(options)), this._client);
     }
 
     /** Adds an HTTP endpoint */
     withHttpEndpoint(options?: WithHttpEndpointOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)), this._client);
     }
 
     /** Adds an HTTPS endpoint */
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)), this._client);
     }
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -12295,152 +12428,152 @@ class CSharpAppResourcePromiseImpl implements CSharpAppResourcePromise {
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.asHttp2Service()));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.asHttp2Service()), this._client);
     }
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)), this._client);
     }
 
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)), this._client);
     }
 
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)), this._client);
     }
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)), this._client);
     }
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)), this._client);
     }
 
     /** Configures the resource to copy container files from the specified source during publishing */
-    publishWithContainerFiles(source: ResourceWithContainerFiles, destinationPath: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.publishWithContainerFiles(source, destinationPath)));
+    publishWithContainerFiles(source: Awaitable<ResourceWithContainerFiles>, destinationPath: string): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.publishWithContainerFiles(source, destinationPath)), this._client);
     }
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()), this._client);
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)), this._client);
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)), this._client);
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()), this._client);
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)));
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)), this._client);
     }
 
     /** Adds a health check by key */
     withHealthCheck(key: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)), this._client);
     }
 
     /** Adds an HTTP health check */
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)), this._client);
     }
 
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)), this._client);
     }
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)), this._client);
     }
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)), this._client);
     }
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)), this._client);
     }
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()), this._client);
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)), this._client);
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)), this._client);
     }
 
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)), this._client);
     }
 
     /** Adds an HTTP health probe to the resource */
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)), this._client);
     }
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()), this._client);
     }
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)), this._client);
     }
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)), this._client);
     }
 
     /** Adds a pipeline step to the resource */
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)), this._client);
     }
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)), this._client);
     }
 
     /** Gets the resource name */
@@ -12450,147 +12583,147 @@ class CSharpAppResourcePromiseImpl implements CSharpAppResourcePromise {
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)), this._client);
     }
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)), this._client);
     }
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)), this._client);
     }
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)), this._client);
     }
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)), this._client);
     }
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): CSharpAppResourcePromise {
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)), this._client);
     }
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): CSharpAppResourcePromise {
-        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new CSharpAppResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -12601,7 +12734,7 @@ class CSharpAppResourcePromiseImpl implements CSharpAppResourcePromise {
 
 export interface DotnetToolResource {
     toJSON(): MarshalledHandle;
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): DotnetToolResourcePromise;
     withToolPackage(packageId: string): DotnetToolResourcePromise;
     withToolVersion(version: string): DotnetToolResourcePromise;
@@ -12617,18 +12750,18 @@ export interface DotnetToolResource {
     withOtlpExporter(): DotnetToolResourcePromise;
     withOtlpExporterProtocol(protocol: OtlpProtocol): DotnetToolResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): DotnetToolResourcePromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): DotnetToolResourcePromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): DotnetToolResourcePromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): DotnetToolResourcePromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): DotnetToolResourcePromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): DotnetToolResourcePromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): DotnetToolResourcePromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): DotnetToolResourcePromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): DotnetToolResourcePromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): DotnetToolResourcePromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): DotnetToolResourcePromise;
     withArgs(args: string[]): DotnetToolResourcePromise;
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): DotnetToolResourcePromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): DotnetToolResourcePromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): DotnetToolResourcePromise;
     withReferenceUri(name: string, uri: string): DotnetToolResourcePromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): DotnetToolResourcePromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): DotnetToolResourcePromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): DotnetToolResourcePromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): DotnetToolResourcePromise;
     withEndpoint(options?: WithEndpointOptions): DotnetToolResourcePromise;
     withHttpEndpoint(options?: WithHttpEndpointOptions): DotnetToolResourcePromise;
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): DotnetToolResourcePromise;
@@ -12641,12 +12774,12 @@ export interface DotnetToolResource {
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): DotnetToolResourcePromise;
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): DotnetToolResourcePromise;
     excludeFromManifest(): DotnetToolResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): DotnetToolResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): DotnetToolResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): DotnetToolResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): DotnetToolResourcePromise;
     withExplicitStart(): DotnetToolResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): DotnetToolResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): DotnetToolResourcePromise;
     withHealthCheck(key: string): DotnetToolResourcePromise;
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): DotnetToolResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): DotnetToolResourcePromise;
@@ -12654,8 +12787,8 @@ export interface DotnetToolResource {
     withCertificateTrustScope(scope: CertificateTrustScope): DotnetToolResourcePromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): DotnetToolResourcePromise;
     withoutHttpsCertificate(): DotnetToolResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): DotnetToolResourcePromise;
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): DotnetToolResourcePromise;
     excludeFromMcp(): DotnetToolResourcePromise;
@@ -12679,9 +12812,9 @@ export interface DotnetToolResource {
     withStatus(status: TestResourceStatus): DotnetToolResourcePromise;
     withNestedConfig(config: TestNestedDto): DotnetToolResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): DotnetToolResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): DotnetToolResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): DotnetToolResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): DotnetToolResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): DotnetToolResourcePromise;
     withEndpoints(endpoints: string[]): DotnetToolResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): DotnetToolResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): DotnetToolResourcePromise;
@@ -12696,7 +12829,7 @@ export interface DotnetToolResource {
 }
 
 export interface DotnetToolResourcePromise extends PromiseLike<DotnetToolResource> {
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): DotnetToolResourcePromise;
     withToolPackage(packageId: string): DotnetToolResourcePromise;
     withToolVersion(version: string): DotnetToolResourcePromise;
@@ -12712,18 +12845,18 @@ export interface DotnetToolResourcePromise extends PromiseLike<DotnetToolResourc
     withOtlpExporter(): DotnetToolResourcePromise;
     withOtlpExporterProtocol(protocol: OtlpProtocol): DotnetToolResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): DotnetToolResourcePromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): DotnetToolResourcePromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): DotnetToolResourcePromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): DotnetToolResourcePromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): DotnetToolResourcePromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): DotnetToolResourcePromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): DotnetToolResourcePromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): DotnetToolResourcePromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): DotnetToolResourcePromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): DotnetToolResourcePromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): DotnetToolResourcePromise;
     withArgs(args: string[]): DotnetToolResourcePromise;
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): DotnetToolResourcePromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): DotnetToolResourcePromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): DotnetToolResourcePromise;
     withReferenceUri(name: string, uri: string): DotnetToolResourcePromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): DotnetToolResourcePromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): DotnetToolResourcePromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): DotnetToolResourcePromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): DotnetToolResourcePromise;
     withEndpoint(options?: WithEndpointOptions): DotnetToolResourcePromise;
     withHttpEndpoint(options?: WithHttpEndpointOptions): DotnetToolResourcePromise;
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): DotnetToolResourcePromise;
@@ -12736,12 +12869,12 @@ export interface DotnetToolResourcePromise extends PromiseLike<DotnetToolResourc
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): DotnetToolResourcePromise;
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): DotnetToolResourcePromise;
     excludeFromManifest(): DotnetToolResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): DotnetToolResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): DotnetToolResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): DotnetToolResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): DotnetToolResourcePromise;
     withExplicitStart(): DotnetToolResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): DotnetToolResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): DotnetToolResourcePromise;
     withHealthCheck(key: string): DotnetToolResourcePromise;
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): DotnetToolResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): DotnetToolResourcePromise;
@@ -12749,8 +12882,8 @@ export interface DotnetToolResourcePromise extends PromiseLike<DotnetToolResourc
     withCertificateTrustScope(scope: CertificateTrustScope): DotnetToolResourcePromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): DotnetToolResourcePromise;
     withoutHttpsCertificate(): DotnetToolResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): DotnetToolResourcePromise;
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): DotnetToolResourcePromise;
     excludeFromMcp(): DotnetToolResourcePromise;
@@ -12774,9 +12907,9 @@ export interface DotnetToolResourcePromise extends PromiseLike<DotnetToolResourc
     withStatus(status: TestResourceStatus): DotnetToolResourcePromise;
     withNestedConfig(config: TestNestedDto): DotnetToolResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): DotnetToolResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): DotnetToolResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): DotnetToolResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): DotnetToolResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): DotnetToolResourcePromise;
     withEndpoints(endpoints: string[]): DotnetToolResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): DotnetToolResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): DotnetToolResourcePromise;
@@ -12800,7 +12933,8 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     }
 
     /** @internal */
-    private async _withContainerRegistryInternal(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<DotnetToolResource> {
+    private async _withContainerRegistryInternal(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<DotnetToolResource> {
+        registry = isPromiseLike(registry) ? await registry : registry;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, registry };
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
             'Aspire.Hosting/withContainerRegistry',
@@ -12810,8 +12944,8 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withContainerRegistryInternal(registry));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._withContainerRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -12830,7 +12964,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): DotnetToolResourcePromise {
         const buildImage = options?.buildImage;
         const runtimeImage = options?.runtimeImage;
-        return new DotnetToolResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage));
+        return new DotnetToolResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage), this._client);
     }
 
     /** @internal */
@@ -12845,7 +12979,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Sets the tool package ID */
     withToolPackage(packageId: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withToolPackageInternal(packageId));
+        return new DotnetToolResourcePromiseImpl(this._withToolPackageInternal(packageId), this._client);
     }
 
     /** @internal */
@@ -12860,7 +12994,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Sets the tool version */
     withToolVersion(version: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withToolVersionInternal(version));
+        return new DotnetToolResourcePromiseImpl(this._withToolVersionInternal(version), this._client);
     }
 
     /** @internal */
@@ -12875,7 +13009,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Allows prerelease tool versions */
     withToolPrerelease(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withToolPrereleaseInternal());
+        return new DotnetToolResourcePromiseImpl(this._withToolPrereleaseInternal(), this._client);
     }
 
     /** @internal */
@@ -12890,7 +13024,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Adds a NuGet source for the tool */
     withToolSource(source: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withToolSourceInternal(source));
+        return new DotnetToolResourcePromiseImpl(this._withToolSourceInternal(source), this._client);
     }
 
     /** @internal */
@@ -12905,7 +13039,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Ignores existing NuGet feeds */
     withToolIgnoreExistingFeeds(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withToolIgnoreExistingFeedsInternal());
+        return new DotnetToolResourcePromiseImpl(this._withToolIgnoreExistingFeedsInternal(), this._client);
     }
 
     /** @internal */
@@ -12920,7 +13054,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Ignores failed NuGet sources */
     withToolIgnoreFailedSources(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withToolIgnoreFailedSourcesInternal());
+        return new DotnetToolResourcePromiseImpl(this._withToolIgnoreFailedSourcesInternal(), this._client);
     }
 
     /** @internal */
@@ -12935,7 +13069,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Publishes the executable as a Docker container */
     publishAsDockerFile(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._publishAsDockerFileInternal());
+        return new DotnetToolResourcePromiseImpl(this._publishAsDockerFileInternal(), this._client);
     }
 
     /** @internal */
@@ -12955,7 +13089,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Publishes an executable as a Docker file with optional container configuration */
     publishAsDockerFileWithConfigure(configure: (obj: ContainerResource) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._publishAsDockerFileWithConfigureInternal(configure));
+        return new DotnetToolResourcePromiseImpl(this._publishAsDockerFileWithConfigureInternal(configure), this._client);
     }
 
     /** @internal */
@@ -12970,7 +13104,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Sets the executable command */
     withExecutableCommand(command: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withExecutableCommandInternal(command));
+        return new DotnetToolResourcePromiseImpl(this._withExecutableCommandInternal(command), this._client);
     }
 
     /** @internal */
@@ -12985,7 +13119,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Sets the executable working directory */
     withWorkingDirectory(workingDirectory: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withWorkingDirectoryInternal(workingDirectory));
+        return new DotnetToolResourcePromiseImpl(this._withWorkingDirectoryInternal(workingDirectory), this._client);
     }
 
     /** @internal */
@@ -13004,7 +13138,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     withMcpServer(options?: WithMcpServerOptions): DotnetToolResourcePromise {
         const path = options?.path;
         const endpointName = options?.endpointName;
-        return new DotnetToolResourcePromiseImpl(this._withMcpServerInternal(path, endpointName));
+        return new DotnetToolResourcePromiseImpl(this._withMcpServerInternal(path, endpointName), this._client);
     }
 
     /** @internal */
@@ -13019,7 +13153,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withOtlpExporterInternal());
+        return new DotnetToolResourcePromiseImpl(this._withOtlpExporterInternal(), this._client);
     }
 
     /** @internal */
@@ -13034,7 +13168,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withOtlpExporterProtocolInternal(protocol));
+        return new DotnetToolResourcePromiseImpl(this._withOtlpExporterProtocolInternal(protocol), this._client);
     }
 
     /** @internal */
@@ -13051,11 +13185,12 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): DotnetToolResourcePromise {
         const helpLink = options?.helpLink;
-        return new DotnetToolResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink));
+        return new DotnetToolResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): Promise<DotnetToolResource> {
+    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): Promise<DotnetToolResource> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
             'Aspire.Hosting/withEnvironment',
@@ -13065,8 +13200,8 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withEnvironmentInternal(name, value));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._withEnvironmentInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -13084,7 +13219,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withEnvironmentExpressionInternal(name, value));
+        return new DotnetToolResourcePromiseImpl(this._withEnvironmentExpressionInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -13104,11 +13239,12 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withEnvironmentCallbackInternal(callback));
+        return new DotnetToolResourcePromiseImpl(this._withEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentEndpointInternal(name: string, endpointReference: EndpointReference): Promise<DotnetToolResource> {
+    private async _withEnvironmentEndpointInternal(name: string, endpointReference: Awaitable<EndpointReference>): Promise<DotnetToolResource> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, endpointReference };
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
             'Aspire.Hosting/withEnvironmentEndpoint',
@@ -13121,12 +13257,13 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentParameterInternal(name: string, parameter: ParameterResource): Promise<DotnetToolResource> {
+    private async _withEnvironmentParameterInternal(name: string, parameter: Awaitable<ParameterResource>): Promise<DotnetToolResource> {
+        parameter = isPromiseLike(parameter) ? await parameter : parameter;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, parameter };
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
             'Aspire.Hosting/withEnvironmentParameter',
@@ -13139,12 +13276,13 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withEnvironmentParameterInternal(name, parameter));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._withEnvironmentParameterInternal(name, parameter), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<DotnetToolResource> {
+    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<DotnetToolResource> {
+        resource = isPromiseLike(resource) ? await resource : resource;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, envVarName, resource };
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
             'Aspire.Hosting/withEnvironmentConnectionString',
@@ -13157,8 +13295,8 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource), this._client);
     }
 
     /** @internal */
@@ -13173,7 +13311,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Adds arguments */
     withArgs(args: string[]): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withArgsInternal(args));
+        return new DotnetToolResourcePromiseImpl(this._withArgsInternal(args), this._client);
     }
 
     /** @internal */
@@ -13193,11 +13331,12 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withArgsCallbackInternal(callback));
+        return new DotnetToolResourcePromiseImpl(this._withArgsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withReferenceInternal(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, connectionName?: string, optional?: boolean, name?: string): Promise<DotnetToolResource> {
+    private async _withReferenceInternal(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, connectionName?: string, optional?: boolean, name?: string): Promise<DotnetToolResource> {
+        source = isPromiseLike(source) ? await source : source;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, source };
         if (connectionName !== undefined) rpcArgs.connectionName = connectionName;
         if (optional !== undefined) rpcArgs.optional = optional;
@@ -13210,11 +13349,11 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): DotnetToolResourcePromise {
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): DotnetToolResourcePromise {
         const connectionName = options?.connectionName;
         const optional = options?.optional;
         const name = options?.name;
-        return new DotnetToolResourcePromiseImpl(this._withReferenceInternal(source, connectionName, optional, name));
+        return new DotnetToolResourcePromiseImpl(this._withReferenceInternal(source, connectionName, optional, name), this._client);
     }
 
     /** @internal */
@@ -13229,11 +13368,12 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withReferenceUriInternal(name, uri));
+        return new DotnetToolResourcePromiseImpl(this._withReferenceUriInternal(name, uri), this._client);
     }
 
     /** @internal */
-    private async _withReferenceExternalServiceInternal(externalService: ExternalServiceResource): Promise<DotnetToolResource> {
+    private async _withReferenceExternalServiceInternal(externalService: Awaitable<ExternalServiceResource>): Promise<DotnetToolResource> {
+        externalService = isPromiseLike(externalService) ? await externalService : externalService;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, externalService };
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
             'Aspire.Hosting/withReferenceExternalService',
@@ -13243,12 +13383,13 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withReferenceExternalServiceInternal(externalService));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._withReferenceExternalServiceInternal(externalService), this._client);
     }
 
     /** @internal */
-    private async _withReferenceEndpointInternal(endpointReference: EndpointReference): Promise<DotnetToolResource> {
+    private async _withReferenceEndpointInternal(endpointReference: Awaitable<EndpointReference>): Promise<DotnetToolResource> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, endpointReference };
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
             'Aspire.Hosting/withReferenceEndpoint',
@@ -13258,8 +13399,8 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withReferenceEndpointInternal(endpointReference));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._withReferenceEndpointInternal(endpointReference), this._client);
     }
 
     /** @internal */
@@ -13290,7 +13431,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
         const isProxied = options?.isProxied;
         const isExternal = options?.isExternal;
         const protocol = options?.protocol;
-        return new DotnetToolResourcePromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol));
+        return new DotnetToolResourcePromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol), this._client);
     }
 
     /** @internal */
@@ -13315,7 +13456,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new DotnetToolResourcePromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied));
+        return new DotnetToolResourcePromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -13340,7 +13481,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new DotnetToolResourcePromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied));
+        return new DotnetToolResourcePromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -13355,7 +13496,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withExternalHttpEndpointsInternal());
+        return new DotnetToolResourcePromiseImpl(this._withExternalHttpEndpointsInternal(), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -13379,7 +13520,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._asHttp2ServiceInternal());
+        return new DotnetToolResourcePromiseImpl(this._asHttp2ServiceInternal(), this._client);
     }
 
     /** @internal */
@@ -13399,7 +13540,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withUrlsCallbackInternal(callback));
+        return new DotnetToolResourcePromiseImpl(this._withUrlsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -13416,7 +13557,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): DotnetToolResourcePromise {
         const displayText = options?.displayText;
-        return new DotnetToolResourcePromiseImpl(this._withUrlInternal(url, displayText));
+        return new DotnetToolResourcePromiseImpl(this._withUrlInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -13433,7 +13574,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): DotnetToolResourcePromise {
         const displayText = options?.displayText;
-        return new DotnetToolResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText));
+        return new DotnetToolResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -13452,7 +13593,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback));
+        return new DotnetToolResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -13472,7 +13613,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback));
+        return new DotnetToolResourcePromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -13487,11 +13628,12 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._excludeFromManifestInternal());
+        return new DotnetToolResourcePromiseImpl(this._excludeFromManifestInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<DotnetToolResource> {
+    private async _waitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<DotnetToolResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
             'Aspire.Hosting/waitForResource',
@@ -13501,12 +13643,13 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._waitForInternal(dependency));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._waitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<DotnetToolResource> {
+    private async _waitForWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<DotnetToolResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
             'Aspire.Hosting/waitForWithBehavior',
@@ -13516,12 +13659,13 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
-    private async _waitForStartInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<DotnetToolResource> {
+    private async _waitForStartInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<DotnetToolResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
             'Aspire.Hosting/waitForResourceStart',
@@ -13531,12 +13675,13 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._waitForStartInternal(dependency));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._waitForStartInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForStartWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<DotnetToolResource> {
+    private async _waitForStartWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<DotnetToolResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
             'Aspire.Hosting/waitForStartWithBehavior',
@@ -13546,8 +13691,8 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
@@ -13562,11 +13707,12 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withExplicitStartInternal());
+        return new DotnetToolResourcePromiseImpl(this._withExplicitStartInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForCompletionInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, exitCode?: number): Promise<DotnetToolResource> {
+    private async _waitForCompletionInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, exitCode?: number): Promise<DotnetToolResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         if (exitCode !== undefined) rpcArgs.exitCode = exitCode;
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
@@ -13577,9 +13723,9 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): DotnetToolResourcePromise {
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): DotnetToolResourcePromise {
         const exitCode = options?.exitCode;
-        return new DotnetToolResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode));
+        return new DotnetToolResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode), this._client);
     }
 
     /** @internal */
@@ -13594,7 +13740,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Adds a health check by key */
     withHealthCheck(key: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withHealthCheckInternal(key));
+        return new DotnetToolResourcePromiseImpl(this._withHealthCheckInternal(key), this._client);
     }
 
     /** @internal */
@@ -13615,7 +13761,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
         const path = options?.path;
         const statusCode = options?.statusCode;
         const endpointName = options?.endpointName;
-        return new DotnetToolResourcePromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName));
+        return new DotnetToolResourcePromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName), this._client);
     }
 
     /** @internal */
@@ -13637,7 +13783,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): DotnetToolResourcePromise {
         const commandOptions = options?.commandOptions;
-        return new DotnetToolResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions));
+        return new DotnetToolResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions), this._client);
     }
 
     /** @internal */
@@ -13652,7 +13798,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withDeveloperCertificateTrustInternal(trust));
+        return new DotnetToolResourcePromiseImpl(this._withDeveloperCertificateTrustInternal(trust), this._client);
     }
 
     /** @internal */
@@ -13667,11 +13813,12 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withCertificateTrustScopeInternal(scope));
+        return new DotnetToolResourcePromiseImpl(this._withCertificateTrustScopeInternal(scope), this._client);
     }
 
     /** @internal */
-    private async _withHttpsDeveloperCertificateInternal(password?: ParameterResource): Promise<DotnetToolResource> {
+    private async _withHttpsDeveloperCertificateInternal(password?: Awaitable<ParameterResource>): Promise<DotnetToolResource> {
+        password = isPromiseLike(password) ? await password : password;
         const rpcArgs: Record<string, unknown> = { builder: this._handle };
         if (password !== undefined) rpcArgs.password = password;
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
@@ -13683,8 +13830,8 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): DotnetToolResourcePromise {
-        const password = options?.password;
-        return new DotnetToolResourcePromiseImpl(this._withHttpsDeveloperCertificateInternal(password));
+        let password = options?.password;
+        return new DotnetToolResourcePromiseImpl(this._withHttpsDeveloperCertificateInternal(password), this._client);
     }
 
     /** @internal */
@@ -13699,11 +13846,12 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withoutHttpsCertificateInternal());
+        return new DotnetToolResourcePromiseImpl(this._withoutHttpsCertificateInternal(), this._client);
     }
 
     /** @internal */
-    private async _withParentRelationshipInternal(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<DotnetToolResource> {
+    private async _withParentRelationshipInternal(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<DotnetToolResource> {
+        parent = isPromiseLike(parent) ? await parent : parent;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, parent };
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
             'Aspire.Hosting/withBuilderParentRelationship',
@@ -13713,12 +13861,13 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withParentRelationshipInternal(parent));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._withParentRelationshipInternal(parent), this._client);
     }
 
     /** @internal */
-    private async _withChildRelationshipInternal(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<DotnetToolResource> {
+    private async _withChildRelationshipInternal(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<DotnetToolResource> {
+        child = isPromiseLike(child) ? await child : child;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, child };
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
             'Aspire.Hosting/withBuilderChildRelationship',
@@ -13728,8 +13877,8 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withChildRelationshipInternal(child));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._withChildRelationshipInternal(child), this._client);
     }
 
     /** @internal */
@@ -13746,7 +13895,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): DotnetToolResourcePromise {
         const iconVariant = options?.iconVariant;
-        return new DotnetToolResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant));
+        return new DotnetToolResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant), this._client);
     }
 
     /** @internal */
@@ -13775,7 +13924,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
         const failureThreshold = options?.failureThreshold;
         const successThreshold = options?.successThreshold;
         const endpointName = options?.endpointName;
-        return new DotnetToolResourcePromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName));
+        return new DotnetToolResourcePromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName), this._client);
     }
 
     /** @internal */
@@ -13790,7 +13939,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._excludeFromMcpInternal());
+        return new DotnetToolResourcePromiseImpl(this._excludeFromMcpInternal(), this._client);
     }
 
     /** @internal */
@@ -13805,7 +13954,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName));
+        return new DotnetToolResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName), this._client);
     }
 
     /** @internal */
@@ -13820,7 +13969,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag));
+        return new DotnetToolResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag), this._client);
     }
 
     /** @internal */
@@ -13848,7 +13997,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
         const requiredBy = options?.requiredBy;
         const tags = options?.tags;
         const description = options?.description;
-        return new DotnetToolResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description));
+        return new DotnetToolResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description), this._client);
     }
 
     /** @internal */
@@ -13868,7 +14017,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withPipelineConfigurationInternal(callback));
+        return new DotnetToolResourcePromiseImpl(this._withPipelineConfigurationInternal(callback), this._client);
     }
 
     /** Gets the resource name */
@@ -13897,7 +14046,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback));
+        return new DotnetToolResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -13917,7 +14066,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._onResourceStoppedInternal(callback));
+        return new DotnetToolResourcePromiseImpl(this._onResourceStoppedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -13937,7 +14086,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._onInitializeResourceInternal(callback));
+        return new DotnetToolResourcePromiseImpl(this._onInitializeResourceInternal(callback), this._client);
     }
 
     /** @internal */
@@ -13957,7 +14106,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._onResourceEndpointsAllocatedInternal(callback));
+        return new DotnetToolResourcePromiseImpl(this._onResourceEndpointsAllocatedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -13977,7 +14126,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._onResourceReadyInternal(callback));
+        return new DotnetToolResourcePromiseImpl(this._onResourceReadyInternal(callback), this._client);
     }
 
     /** @internal */
@@ -13996,7 +14145,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     withOptionalString(options?: WithOptionalStringOptions): DotnetToolResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new DotnetToolResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new DotnetToolResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -14011,7 +14160,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withConfigInternal(config));
+        return new DotnetToolResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -14031,7 +14180,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback));
+        return new DotnetToolResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -14046,7 +14195,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new DotnetToolResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -14061,7 +14210,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new DotnetToolResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -14076,7 +14225,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new DotnetToolResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -14098,7 +14247,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): DotnetToolResourcePromise {
         const callback = options?.callback;
-        return new DotnetToolResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new DotnetToolResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -14113,7 +14262,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withStatusInternal(status));
+        return new DotnetToolResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -14128,7 +14277,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new DotnetToolResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -14148,11 +14297,12 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new DotnetToolResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<DotnetToolResource> {
+    private async _testWaitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<DotnetToolResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -14162,12 +14312,13 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<DotnetToolResource> {
+    private async _withDependencyInternal(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<DotnetToolResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -14177,12 +14328,13 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<DotnetToolResource> {
+    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<DotnetToolResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<DotnetToolResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -14192,8 +14344,8 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -14208,7 +14360,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new DotnetToolResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -14223,7 +14375,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables));
+        return new DotnetToolResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables), this._client);
     }
 
     /** @internal */
@@ -14242,7 +14394,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new DotnetToolResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** @internal */
@@ -14257,7 +14409,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new DotnetToolResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -14272,7 +14424,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new DotnetToolResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -14287,7 +14439,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new DotnetToolResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -14302,7 +14454,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new DotnetToolResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -14321,7 +14473,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): DotnetToolResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new DotnetToolResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new DotnetToolResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -14340,7 +14492,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): DotnetToolResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new DotnetToolResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new DotnetToolResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -14355,7 +14507,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new DotnetToolResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -14370,7 +14522,7 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new DotnetToolResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -14381,7 +14533,9 @@ class DotnetToolResourceImpl extends ResourceBuilderBase<DotnetToolResourceHandl
  * await builder.addSomething().withX().withY();
  */
 class DotnetToolResourcePromiseImpl implements DotnetToolResourcePromise {
-    constructor(private _promise: Promise<DotnetToolResource>) {}
+    constructor(private _promise: Promise<DotnetToolResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = DotnetToolResource, TResult2 = never>(
         onfulfilled?: ((value: DotnetToolResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -14391,88 +14545,88 @@ class DotnetToolResourcePromiseImpl implements DotnetToolResourcePromise {
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)), this._client);
     }
 
     /** Sets the base image for a Dockerfile build */
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)), this._client);
     }
 
     /** Sets the tool package ID */
     withToolPackage(packageId: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withToolPackage(packageId)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withToolPackage(packageId)), this._client);
     }
 
     /** Sets the tool version */
     withToolVersion(version: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withToolVersion(version)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withToolVersion(version)), this._client);
     }
 
     /** Allows prerelease tool versions */
     withToolPrerelease(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withToolPrerelease()));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withToolPrerelease()), this._client);
     }
 
     /** Adds a NuGet source for the tool */
     withToolSource(source: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withToolSource(source)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withToolSource(source)), this._client);
     }
 
     /** Ignores existing NuGet feeds */
     withToolIgnoreExistingFeeds(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withToolIgnoreExistingFeeds()));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withToolIgnoreExistingFeeds()), this._client);
     }
 
     /** Ignores failed NuGet sources */
     withToolIgnoreFailedSources(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withToolIgnoreFailedSources()));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withToolIgnoreFailedSources()), this._client);
     }
 
     /** Publishes the executable as a Docker container */
     publishAsDockerFile(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.publishAsDockerFile()));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.publishAsDockerFile()), this._client);
     }
 
     /** Publishes an executable as a Docker file with optional container configuration */
     publishAsDockerFileWithConfigure(configure: (obj: ContainerResource) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.publishAsDockerFileWithConfigure(configure)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.publishAsDockerFileWithConfigure(configure)), this._client);
     }
 
     /** Sets the executable command */
     withExecutableCommand(command: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withExecutableCommand(command)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withExecutableCommand(command)), this._client);
     }
 
     /** Sets the executable working directory */
     withWorkingDirectory(workingDirectory: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withWorkingDirectory(workingDirectory)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withWorkingDirectory(workingDirectory)), this._client);
     }
 
     /** Configures an MCP server endpoint on the resource */
     withMcpServer(options?: WithMcpServerOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMcpServer(options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMcpServer(options)), this._client);
     }
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporter()));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporter()), this._client);
     }
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)), this._client);
     }
 
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)), this._client);
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)), this._client);
     }
 
     /**
@@ -14480,86 +14634,86 @@ class DotnetToolResourcePromiseImpl implements DotnetToolResourcePromise {
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)), this._client);
     }
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)), this._client);
     }
 
     /**
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)), this._client);
     }
 
     /**
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)), this._client);
     }
 
     /**
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)), this._client);
     }
 
     /** Adds arguments */
     withArgs(args: string[]): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withArgs(args)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withArgs(args)), this._client);
     }
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)), this._client);
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withReference(source, options)));
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withReference(source, options)), this._client);
     }
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)), this._client);
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)), this._client);
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)), this._client);
     }
 
     /** Adds a network endpoint */
     withEndpoint(options?: WithEndpointOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEndpoint(options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEndpoint(options)), this._client);
     }
 
     /** Adds an HTTP endpoint */
     withHttpEndpoint(options?: WithHttpEndpointOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)), this._client);
     }
 
     /** Adds an HTTPS endpoint */
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)), this._client);
     }
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -14569,147 +14723,147 @@ class DotnetToolResourcePromiseImpl implements DotnetToolResourcePromise {
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.asHttp2Service()));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.asHttp2Service()), this._client);
     }
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)), this._client);
     }
 
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)), this._client);
     }
 
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)), this._client);
     }
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)), this._client);
     }
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)), this._client);
     }
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()), this._client);
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)), this._client);
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)), this._client);
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()), this._client);
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)));
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)), this._client);
     }
 
     /** Adds a health check by key */
     withHealthCheck(key: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)), this._client);
     }
 
     /** Adds an HTTP health check */
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)), this._client);
     }
 
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)), this._client);
     }
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)), this._client);
     }
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)), this._client);
     }
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)), this._client);
     }
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()), this._client);
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)), this._client);
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)), this._client);
     }
 
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)), this._client);
     }
 
     /** Adds an HTTP health probe to the resource */
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)), this._client);
     }
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()), this._client);
     }
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)), this._client);
     }
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)), this._client);
     }
 
     /** Adds a pipeline step to the resource */
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)), this._client);
     }
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)), this._client);
     }
 
     /** Gets the resource name */
@@ -14719,147 +14873,147 @@ class DotnetToolResourcePromiseImpl implements DotnetToolResourcePromise {
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)), this._client);
     }
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)), this._client);
     }
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)), this._client);
     }
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)), this._client);
     }
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)), this._client);
     }
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): DotnetToolResourcePromise {
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)), this._client);
     }
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): DotnetToolResourcePromise {
-        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new DotnetToolResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -14870,7 +15024,7 @@ class DotnetToolResourcePromiseImpl implements DotnetToolResourcePromise {
 
 export interface ExecutableResource {
     toJSON(): MarshalledHandle;
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ExecutableResourcePromise;
     publishAsDockerFile(): ExecutableResourcePromise;
     publishAsDockerFileWithConfigure(configure: (obj: ContainerResource) => Promise<void>): ExecutableResourcePromise;
@@ -14880,18 +15034,18 @@ export interface ExecutableResource {
     withOtlpExporter(): ExecutableResourcePromise;
     withOtlpExporterProtocol(protocol: OtlpProtocol): ExecutableResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ExecutableResourcePromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): ExecutableResourcePromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): ExecutableResourcePromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): ExecutableResourcePromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): ExecutableResourcePromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): ExecutableResourcePromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): ExecutableResourcePromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExecutableResourcePromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): ExecutableResourcePromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): ExecutableResourcePromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExecutableResourcePromise;
     withArgs(args: string[]): ExecutableResourcePromise;
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): ExecutableResourcePromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): ExecutableResourcePromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): ExecutableResourcePromise;
     withReferenceUri(name: string, uri: string): ExecutableResourcePromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): ExecutableResourcePromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): ExecutableResourcePromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): ExecutableResourcePromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): ExecutableResourcePromise;
     withEndpoint(options?: WithEndpointOptions): ExecutableResourcePromise;
     withHttpEndpoint(options?: WithHttpEndpointOptions): ExecutableResourcePromise;
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): ExecutableResourcePromise;
@@ -14904,12 +15058,12 @@ export interface ExecutableResource {
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ExecutableResourcePromise;
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): ExecutableResourcePromise;
     excludeFromManifest(): ExecutableResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ExecutableResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ExecutableResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ExecutableResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ExecutableResourcePromise;
     withExplicitStart(): ExecutableResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ExecutableResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ExecutableResourcePromise;
     withHealthCheck(key: string): ExecutableResourcePromise;
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): ExecutableResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ExecutableResourcePromise;
@@ -14917,8 +15071,8 @@ export interface ExecutableResource {
     withCertificateTrustScope(scope: CertificateTrustScope): ExecutableResourcePromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): ExecutableResourcePromise;
     withoutHttpsCertificate(): ExecutableResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): ExecutableResourcePromise;
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): ExecutableResourcePromise;
     excludeFromMcp(): ExecutableResourcePromise;
@@ -14942,9 +15096,9 @@ export interface ExecutableResource {
     withStatus(status: TestResourceStatus): ExecutableResourcePromise;
     withNestedConfig(config: TestNestedDto): ExecutableResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ExecutableResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExecutableResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExecutableResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExecutableResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExecutableResourcePromise;
     withEndpoints(endpoints: string[]): ExecutableResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): ExecutableResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ExecutableResourcePromise;
@@ -14959,7 +15113,7 @@ export interface ExecutableResource {
 }
 
 export interface ExecutableResourcePromise extends PromiseLike<ExecutableResource> {
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ExecutableResourcePromise;
     publishAsDockerFile(): ExecutableResourcePromise;
     publishAsDockerFileWithConfigure(configure: (obj: ContainerResource) => Promise<void>): ExecutableResourcePromise;
@@ -14969,18 +15123,18 @@ export interface ExecutableResourcePromise extends PromiseLike<ExecutableResourc
     withOtlpExporter(): ExecutableResourcePromise;
     withOtlpExporterProtocol(protocol: OtlpProtocol): ExecutableResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ExecutableResourcePromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): ExecutableResourcePromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): ExecutableResourcePromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): ExecutableResourcePromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): ExecutableResourcePromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): ExecutableResourcePromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): ExecutableResourcePromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExecutableResourcePromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): ExecutableResourcePromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): ExecutableResourcePromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExecutableResourcePromise;
     withArgs(args: string[]): ExecutableResourcePromise;
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): ExecutableResourcePromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): ExecutableResourcePromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): ExecutableResourcePromise;
     withReferenceUri(name: string, uri: string): ExecutableResourcePromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): ExecutableResourcePromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): ExecutableResourcePromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): ExecutableResourcePromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): ExecutableResourcePromise;
     withEndpoint(options?: WithEndpointOptions): ExecutableResourcePromise;
     withHttpEndpoint(options?: WithHttpEndpointOptions): ExecutableResourcePromise;
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): ExecutableResourcePromise;
@@ -14993,12 +15147,12 @@ export interface ExecutableResourcePromise extends PromiseLike<ExecutableResourc
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ExecutableResourcePromise;
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): ExecutableResourcePromise;
     excludeFromManifest(): ExecutableResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ExecutableResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ExecutableResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ExecutableResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ExecutableResourcePromise;
     withExplicitStart(): ExecutableResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ExecutableResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ExecutableResourcePromise;
     withHealthCheck(key: string): ExecutableResourcePromise;
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): ExecutableResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ExecutableResourcePromise;
@@ -15006,8 +15160,8 @@ export interface ExecutableResourcePromise extends PromiseLike<ExecutableResourc
     withCertificateTrustScope(scope: CertificateTrustScope): ExecutableResourcePromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): ExecutableResourcePromise;
     withoutHttpsCertificate(): ExecutableResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): ExecutableResourcePromise;
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): ExecutableResourcePromise;
     excludeFromMcp(): ExecutableResourcePromise;
@@ -15031,9 +15185,9 @@ export interface ExecutableResourcePromise extends PromiseLike<ExecutableResourc
     withStatus(status: TestResourceStatus): ExecutableResourcePromise;
     withNestedConfig(config: TestNestedDto): ExecutableResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ExecutableResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExecutableResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExecutableResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExecutableResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExecutableResourcePromise;
     withEndpoints(endpoints: string[]): ExecutableResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): ExecutableResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ExecutableResourcePromise;
@@ -15057,7 +15211,8 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     }
 
     /** @internal */
-    private async _withContainerRegistryInternal(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ExecutableResource> {
+    private async _withContainerRegistryInternal(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ExecutableResource> {
+        registry = isPromiseLike(registry) ? await registry : registry;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, registry };
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
             'Aspire.Hosting/withContainerRegistry',
@@ -15067,8 +15222,8 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withContainerRegistryInternal(registry));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._withContainerRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -15087,7 +15242,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ExecutableResourcePromise {
         const buildImage = options?.buildImage;
         const runtimeImage = options?.runtimeImage;
-        return new ExecutableResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage));
+        return new ExecutableResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage), this._client);
     }
 
     /** @internal */
@@ -15102,7 +15257,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Publishes the executable as a Docker container */
     publishAsDockerFile(): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._publishAsDockerFileInternal());
+        return new ExecutableResourcePromiseImpl(this._publishAsDockerFileInternal(), this._client);
     }
 
     /** @internal */
@@ -15122,7 +15277,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Publishes an executable as a Docker file with optional container configuration */
     publishAsDockerFileWithConfigure(configure: (obj: ContainerResource) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._publishAsDockerFileWithConfigureInternal(configure));
+        return new ExecutableResourcePromiseImpl(this._publishAsDockerFileWithConfigureInternal(configure), this._client);
     }
 
     /** @internal */
@@ -15137,7 +15292,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Sets the executable command */
     withExecutableCommand(command: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withExecutableCommandInternal(command));
+        return new ExecutableResourcePromiseImpl(this._withExecutableCommandInternal(command), this._client);
     }
 
     /** @internal */
@@ -15152,7 +15307,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Sets the executable working directory */
     withWorkingDirectory(workingDirectory: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withWorkingDirectoryInternal(workingDirectory));
+        return new ExecutableResourcePromiseImpl(this._withWorkingDirectoryInternal(workingDirectory), this._client);
     }
 
     /** @internal */
@@ -15171,7 +15326,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     withMcpServer(options?: WithMcpServerOptions): ExecutableResourcePromise {
         const path = options?.path;
         const endpointName = options?.endpointName;
-        return new ExecutableResourcePromiseImpl(this._withMcpServerInternal(path, endpointName));
+        return new ExecutableResourcePromiseImpl(this._withMcpServerInternal(path, endpointName), this._client);
     }
 
     /** @internal */
@@ -15186,7 +15341,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withOtlpExporterInternal());
+        return new ExecutableResourcePromiseImpl(this._withOtlpExporterInternal(), this._client);
     }
 
     /** @internal */
@@ -15201,7 +15356,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withOtlpExporterProtocolInternal(protocol));
+        return new ExecutableResourcePromiseImpl(this._withOtlpExporterProtocolInternal(protocol), this._client);
     }
 
     /** @internal */
@@ -15218,11 +15373,12 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ExecutableResourcePromise {
         const helpLink = options?.helpLink;
-        return new ExecutableResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink));
+        return new ExecutableResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): Promise<ExecutableResource> {
+    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): Promise<ExecutableResource> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
             'Aspire.Hosting/withEnvironment',
@@ -15232,8 +15388,8 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withEnvironmentInternal(name, value));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._withEnvironmentInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -15251,7 +15407,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withEnvironmentExpressionInternal(name, value));
+        return new ExecutableResourcePromiseImpl(this._withEnvironmentExpressionInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -15271,11 +15427,12 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withEnvironmentCallbackInternal(callback));
+        return new ExecutableResourcePromiseImpl(this._withEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentEndpointInternal(name: string, endpointReference: EndpointReference): Promise<ExecutableResource> {
+    private async _withEnvironmentEndpointInternal(name: string, endpointReference: Awaitable<EndpointReference>): Promise<ExecutableResource> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, endpointReference };
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
             'Aspire.Hosting/withEnvironmentEndpoint',
@@ -15288,12 +15445,13 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentParameterInternal(name: string, parameter: ParameterResource): Promise<ExecutableResource> {
+    private async _withEnvironmentParameterInternal(name: string, parameter: Awaitable<ParameterResource>): Promise<ExecutableResource> {
+        parameter = isPromiseLike(parameter) ? await parameter : parameter;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, parameter };
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
             'Aspire.Hosting/withEnvironmentParameter',
@@ -15306,12 +15464,13 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withEnvironmentParameterInternal(name, parameter));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._withEnvironmentParameterInternal(name, parameter), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ExecutableResource> {
+    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ExecutableResource> {
+        resource = isPromiseLike(resource) ? await resource : resource;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, envVarName, resource };
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
             'Aspire.Hosting/withEnvironmentConnectionString',
@@ -15324,8 +15483,8 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource), this._client);
     }
 
     /** @internal */
@@ -15340,7 +15499,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Adds arguments */
     withArgs(args: string[]): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withArgsInternal(args));
+        return new ExecutableResourcePromiseImpl(this._withArgsInternal(args), this._client);
     }
 
     /** @internal */
@@ -15360,11 +15519,12 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withArgsCallbackInternal(callback));
+        return new ExecutableResourcePromiseImpl(this._withArgsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withReferenceInternal(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, connectionName?: string, optional?: boolean, name?: string): Promise<ExecutableResource> {
+    private async _withReferenceInternal(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, connectionName?: string, optional?: boolean, name?: string): Promise<ExecutableResource> {
+        source = isPromiseLike(source) ? await source : source;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, source };
         if (connectionName !== undefined) rpcArgs.connectionName = connectionName;
         if (optional !== undefined) rpcArgs.optional = optional;
@@ -15377,11 +15537,11 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): ExecutableResourcePromise {
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): ExecutableResourcePromise {
         const connectionName = options?.connectionName;
         const optional = options?.optional;
         const name = options?.name;
-        return new ExecutableResourcePromiseImpl(this._withReferenceInternal(source, connectionName, optional, name));
+        return new ExecutableResourcePromiseImpl(this._withReferenceInternal(source, connectionName, optional, name), this._client);
     }
 
     /** @internal */
@@ -15396,11 +15556,12 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withReferenceUriInternal(name, uri));
+        return new ExecutableResourcePromiseImpl(this._withReferenceUriInternal(name, uri), this._client);
     }
 
     /** @internal */
-    private async _withReferenceExternalServiceInternal(externalService: ExternalServiceResource): Promise<ExecutableResource> {
+    private async _withReferenceExternalServiceInternal(externalService: Awaitable<ExternalServiceResource>): Promise<ExecutableResource> {
+        externalService = isPromiseLike(externalService) ? await externalService : externalService;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, externalService };
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
             'Aspire.Hosting/withReferenceExternalService',
@@ -15410,12 +15571,13 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withReferenceExternalServiceInternal(externalService));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._withReferenceExternalServiceInternal(externalService), this._client);
     }
 
     /** @internal */
-    private async _withReferenceEndpointInternal(endpointReference: EndpointReference): Promise<ExecutableResource> {
+    private async _withReferenceEndpointInternal(endpointReference: Awaitable<EndpointReference>): Promise<ExecutableResource> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, endpointReference };
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
             'Aspire.Hosting/withReferenceEndpoint',
@@ -15425,8 +15587,8 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withReferenceEndpointInternal(endpointReference));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._withReferenceEndpointInternal(endpointReference), this._client);
     }
 
     /** @internal */
@@ -15457,7 +15619,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
         const isProxied = options?.isProxied;
         const isExternal = options?.isExternal;
         const protocol = options?.protocol;
-        return new ExecutableResourcePromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol));
+        return new ExecutableResourcePromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol), this._client);
     }
 
     /** @internal */
@@ -15482,7 +15644,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new ExecutableResourcePromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied));
+        return new ExecutableResourcePromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -15507,7 +15669,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new ExecutableResourcePromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied));
+        return new ExecutableResourcePromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -15522,7 +15684,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withExternalHttpEndpointsInternal());
+        return new ExecutableResourcePromiseImpl(this._withExternalHttpEndpointsInternal(), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -15546,7 +15708,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._asHttp2ServiceInternal());
+        return new ExecutableResourcePromiseImpl(this._asHttp2ServiceInternal(), this._client);
     }
 
     /** @internal */
@@ -15566,7 +15728,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withUrlsCallbackInternal(callback));
+        return new ExecutableResourcePromiseImpl(this._withUrlsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -15583,7 +15745,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): ExecutableResourcePromise {
         const displayText = options?.displayText;
-        return new ExecutableResourcePromiseImpl(this._withUrlInternal(url, displayText));
+        return new ExecutableResourcePromiseImpl(this._withUrlInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -15600,7 +15762,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ExecutableResourcePromise {
         const displayText = options?.displayText;
-        return new ExecutableResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText));
+        return new ExecutableResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -15619,7 +15781,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback));
+        return new ExecutableResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -15639,7 +15801,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback));
+        return new ExecutableResourcePromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -15654,11 +15816,12 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._excludeFromManifestInternal());
+        return new ExecutableResourcePromiseImpl(this._excludeFromManifestInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ExecutableResource> {
+    private async _waitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ExecutableResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
             'Aspire.Hosting/waitForResource',
@@ -15668,12 +15831,13 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._waitForInternal(dependency));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._waitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<ExecutableResource> {
+    private async _waitForWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<ExecutableResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
             'Aspire.Hosting/waitForWithBehavior',
@@ -15683,12 +15847,13 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
-    private async _waitForStartInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ExecutableResource> {
+    private async _waitForStartInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ExecutableResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
             'Aspire.Hosting/waitForResourceStart',
@@ -15698,12 +15863,13 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._waitForStartInternal(dependency));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._waitForStartInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForStartWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<ExecutableResource> {
+    private async _waitForStartWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<ExecutableResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
             'Aspire.Hosting/waitForStartWithBehavior',
@@ -15713,8 +15879,8 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
@@ -15729,11 +15895,12 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withExplicitStartInternal());
+        return new ExecutableResourcePromiseImpl(this._withExplicitStartInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForCompletionInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, exitCode?: number): Promise<ExecutableResource> {
+    private async _waitForCompletionInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, exitCode?: number): Promise<ExecutableResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         if (exitCode !== undefined) rpcArgs.exitCode = exitCode;
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
@@ -15744,9 +15911,9 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ExecutableResourcePromise {
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ExecutableResourcePromise {
         const exitCode = options?.exitCode;
-        return new ExecutableResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode));
+        return new ExecutableResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode), this._client);
     }
 
     /** @internal */
@@ -15761,7 +15928,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Adds a health check by key */
     withHealthCheck(key: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withHealthCheckInternal(key));
+        return new ExecutableResourcePromiseImpl(this._withHealthCheckInternal(key), this._client);
     }
 
     /** @internal */
@@ -15782,7 +15949,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
         const path = options?.path;
         const statusCode = options?.statusCode;
         const endpointName = options?.endpointName;
-        return new ExecutableResourcePromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName));
+        return new ExecutableResourcePromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName), this._client);
     }
 
     /** @internal */
@@ -15804,7 +15971,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ExecutableResourcePromise {
         const commandOptions = options?.commandOptions;
-        return new ExecutableResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions));
+        return new ExecutableResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions), this._client);
     }
 
     /** @internal */
@@ -15819,7 +15986,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withDeveloperCertificateTrustInternal(trust));
+        return new ExecutableResourcePromiseImpl(this._withDeveloperCertificateTrustInternal(trust), this._client);
     }
 
     /** @internal */
@@ -15834,11 +16001,12 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withCertificateTrustScopeInternal(scope));
+        return new ExecutableResourcePromiseImpl(this._withCertificateTrustScopeInternal(scope), this._client);
     }
 
     /** @internal */
-    private async _withHttpsDeveloperCertificateInternal(password?: ParameterResource): Promise<ExecutableResource> {
+    private async _withHttpsDeveloperCertificateInternal(password?: Awaitable<ParameterResource>): Promise<ExecutableResource> {
+        password = isPromiseLike(password) ? await password : password;
         const rpcArgs: Record<string, unknown> = { builder: this._handle };
         if (password !== undefined) rpcArgs.password = password;
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
@@ -15850,8 +16018,8 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): ExecutableResourcePromise {
-        const password = options?.password;
-        return new ExecutableResourcePromiseImpl(this._withHttpsDeveloperCertificateInternal(password));
+        let password = options?.password;
+        return new ExecutableResourcePromiseImpl(this._withHttpsDeveloperCertificateInternal(password), this._client);
     }
 
     /** @internal */
@@ -15866,11 +16034,12 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withoutHttpsCertificateInternal());
+        return new ExecutableResourcePromiseImpl(this._withoutHttpsCertificateInternal(), this._client);
     }
 
     /** @internal */
-    private async _withParentRelationshipInternal(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ExecutableResource> {
+    private async _withParentRelationshipInternal(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ExecutableResource> {
+        parent = isPromiseLike(parent) ? await parent : parent;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, parent };
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
             'Aspire.Hosting/withBuilderParentRelationship',
@@ -15880,12 +16049,13 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withParentRelationshipInternal(parent));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._withParentRelationshipInternal(parent), this._client);
     }
 
     /** @internal */
-    private async _withChildRelationshipInternal(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ExecutableResource> {
+    private async _withChildRelationshipInternal(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ExecutableResource> {
+        child = isPromiseLike(child) ? await child : child;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, child };
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
             'Aspire.Hosting/withBuilderChildRelationship',
@@ -15895,8 +16065,8 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withChildRelationshipInternal(child));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._withChildRelationshipInternal(child), this._client);
     }
 
     /** @internal */
@@ -15913,7 +16083,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): ExecutableResourcePromise {
         const iconVariant = options?.iconVariant;
-        return new ExecutableResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant));
+        return new ExecutableResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant), this._client);
     }
 
     /** @internal */
@@ -15942,7 +16112,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
         const failureThreshold = options?.failureThreshold;
         const successThreshold = options?.successThreshold;
         const endpointName = options?.endpointName;
-        return new ExecutableResourcePromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName));
+        return new ExecutableResourcePromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName), this._client);
     }
 
     /** @internal */
@@ -15957,7 +16127,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._excludeFromMcpInternal());
+        return new ExecutableResourcePromiseImpl(this._excludeFromMcpInternal(), this._client);
     }
 
     /** @internal */
@@ -15972,7 +16142,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName));
+        return new ExecutableResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName), this._client);
     }
 
     /** @internal */
@@ -15987,7 +16157,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag));
+        return new ExecutableResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag), this._client);
     }
 
     /** @internal */
@@ -16015,7 +16185,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
         const requiredBy = options?.requiredBy;
         const tags = options?.tags;
         const description = options?.description;
-        return new ExecutableResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description));
+        return new ExecutableResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description), this._client);
     }
 
     /** @internal */
@@ -16035,7 +16205,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withPipelineConfigurationInternal(callback));
+        return new ExecutableResourcePromiseImpl(this._withPipelineConfigurationInternal(callback), this._client);
     }
 
     /** Gets the resource name */
@@ -16064,7 +16234,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback));
+        return new ExecutableResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -16084,7 +16254,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._onResourceStoppedInternal(callback));
+        return new ExecutableResourcePromiseImpl(this._onResourceStoppedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -16104,7 +16274,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._onInitializeResourceInternal(callback));
+        return new ExecutableResourcePromiseImpl(this._onInitializeResourceInternal(callback), this._client);
     }
 
     /** @internal */
@@ -16124,7 +16294,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._onResourceEndpointsAllocatedInternal(callback));
+        return new ExecutableResourcePromiseImpl(this._onResourceEndpointsAllocatedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -16144,7 +16314,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._onResourceReadyInternal(callback));
+        return new ExecutableResourcePromiseImpl(this._onResourceReadyInternal(callback), this._client);
     }
 
     /** @internal */
@@ -16163,7 +16333,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     withOptionalString(options?: WithOptionalStringOptions): ExecutableResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new ExecutableResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new ExecutableResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -16178,7 +16348,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withConfigInternal(config));
+        return new ExecutableResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -16198,7 +16368,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback));
+        return new ExecutableResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -16213,7 +16383,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new ExecutableResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -16228,7 +16398,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new ExecutableResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -16243,7 +16413,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new ExecutableResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -16265,7 +16435,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ExecutableResourcePromise {
         const callback = options?.callback;
-        return new ExecutableResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new ExecutableResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -16280,7 +16450,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withStatusInternal(status));
+        return new ExecutableResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -16295,7 +16465,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new ExecutableResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -16315,11 +16485,12 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new ExecutableResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ExecutableResource> {
+    private async _testWaitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ExecutableResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -16329,12 +16500,13 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ExecutableResource> {
+    private async _withDependencyInternal(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ExecutableResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -16344,12 +16516,13 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ExecutableResource> {
+    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ExecutableResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ExecutableResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -16359,8 +16532,8 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -16375,7 +16548,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new ExecutableResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -16390,7 +16563,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables));
+        return new ExecutableResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables), this._client);
     }
 
     /** @internal */
@@ -16409,7 +16582,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new ExecutableResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** @internal */
@@ -16424,7 +16597,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new ExecutableResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -16439,7 +16612,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new ExecutableResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -16454,7 +16627,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new ExecutableResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -16469,7 +16642,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new ExecutableResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -16488,7 +16661,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ExecutableResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ExecutableResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new ExecutableResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -16507,7 +16680,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ExecutableResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ExecutableResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new ExecutableResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -16522,7 +16695,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new ExecutableResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -16537,7 +16710,7 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new ExecutableResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -16548,7 +16721,9 @@ class ExecutableResourceImpl extends ResourceBuilderBase<ExecutableResourceHandl
  * await builder.addSomething().withX().withY();
  */
 class ExecutableResourcePromiseImpl implements ExecutableResourcePromise {
-    constructor(private _promise: Promise<ExecutableResource>) {}
+    constructor(private _promise: Promise<ExecutableResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ExecutableResource, TResult2 = never>(
         onfulfilled?: ((value: ExecutableResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -16558,58 +16733,58 @@ class ExecutableResourcePromiseImpl implements ExecutableResourcePromise {
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)), this._client);
     }
 
     /** Sets the base image for a Dockerfile build */
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)), this._client);
     }
 
     /** Publishes the executable as a Docker container */
     publishAsDockerFile(): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.publishAsDockerFile()));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.publishAsDockerFile()), this._client);
     }
 
     /** Publishes an executable as a Docker file with optional container configuration */
     publishAsDockerFileWithConfigure(configure: (obj: ContainerResource) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.publishAsDockerFileWithConfigure(configure)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.publishAsDockerFileWithConfigure(configure)), this._client);
     }
 
     /** Sets the executable command */
     withExecutableCommand(command: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withExecutableCommand(command)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withExecutableCommand(command)), this._client);
     }
 
     /** Sets the executable working directory */
     withWorkingDirectory(workingDirectory: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withWorkingDirectory(workingDirectory)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withWorkingDirectory(workingDirectory)), this._client);
     }
 
     /** Configures an MCP server endpoint on the resource */
     withMcpServer(options?: WithMcpServerOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMcpServer(options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMcpServer(options)), this._client);
     }
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporter()));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporter()), this._client);
     }
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)), this._client);
     }
 
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)), this._client);
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)), this._client);
     }
 
     /**
@@ -16617,86 +16792,86 @@ class ExecutableResourcePromiseImpl implements ExecutableResourcePromise {
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)), this._client);
     }
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)), this._client);
     }
 
     /**
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)), this._client);
     }
 
     /**
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)), this._client);
     }
 
     /**
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)), this._client);
     }
 
     /** Adds arguments */
     withArgs(args: string[]): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withArgs(args)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withArgs(args)), this._client);
     }
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)), this._client);
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withReference(source, options)));
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withReference(source, options)), this._client);
     }
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)), this._client);
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)), this._client);
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)), this._client);
     }
 
     /** Adds a network endpoint */
     withEndpoint(options?: WithEndpointOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEndpoint(options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEndpoint(options)), this._client);
     }
 
     /** Adds an HTTP endpoint */
     withHttpEndpoint(options?: WithHttpEndpointOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)), this._client);
     }
 
     /** Adds an HTTPS endpoint */
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)), this._client);
     }
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -16706,147 +16881,147 @@ class ExecutableResourcePromiseImpl implements ExecutableResourcePromise {
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.asHttp2Service()));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.asHttp2Service()), this._client);
     }
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)), this._client);
     }
 
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)), this._client);
     }
 
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)), this._client);
     }
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)), this._client);
     }
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)), this._client);
     }
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()), this._client);
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)), this._client);
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)), this._client);
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()), this._client);
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)));
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)), this._client);
     }
 
     /** Adds a health check by key */
     withHealthCheck(key: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)), this._client);
     }
 
     /** Adds an HTTP health check */
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)), this._client);
     }
 
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)), this._client);
     }
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)), this._client);
     }
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)), this._client);
     }
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)), this._client);
     }
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()), this._client);
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)), this._client);
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)), this._client);
     }
 
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)), this._client);
     }
 
     /** Adds an HTTP health probe to the resource */
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)), this._client);
     }
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()), this._client);
     }
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)), this._client);
     }
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)), this._client);
     }
 
     /** Adds a pipeline step to the resource */
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)), this._client);
     }
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)), this._client);
     }
 
     /** Gets the resource name */
@@ -16856,147 +17031,147 @@ class ExecutableResourcePromiseImpl implements ExecutableResourcePromise {
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)), this._client);
     }
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)), this._client);
     }
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)), this._client);
     }
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)), this._client);
     }
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)), this._client);
     }
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExecutableResourcePromise {
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)), this._client);
     }
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ExecutableResourcePromise {
-        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new ExecutableResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -17007,7 +17182,7 @@ class ExecutableResourcePromiseImpl implements ExecutableResourcePromise {
 
 export interface ExternalServiceResource {
     toJSON(): MarshalledHandle;
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExternalServiceResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExternalServiceResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ExternalServiceResourcePromise;
     withExternalServiceHttpHealthCheck(options?: WithExternalServiceHttpHealthCheckOptions): ExternalServiceResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ExternalServiceResourcePromise;
@@ -17019,8 +17194,8 @@ export interface ExternalServiceResource {
     withExplicitStart(): ExternalServiceResourcePromise;
     withHealthCheck(key: string): ExternalServiceResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ExternalServiceResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExternalServiceResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExternalServiceResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExternalServiceResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExternalServiceResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): ExternalServiceResourcePromise;
     excludeFromMcp(): ExternalServiceResourcePromise;
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ExternalServiceResourcePromise;
@@ -17039,9 +17214,9 @@ export interface ExternalServiceResource {
     withStatus(status: TestResourceStatus): ExternalServiceResourcePromise;
     withNestedConfig(config: TestNestedDto): ExternalServiceResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ExternalServiceResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExternalServiceResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExternalServiceResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExternalServiceResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExternalServiceResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExternalServiceResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExternalServiceResourcePromise;
     withEndpoints(endpoints: string[]): ExternalServiceResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ExternalServiceResourcePromise;
     withMergeLabel(label: string): ExternalServiceResourcePromise;
@@ -17055,7 +17230,7 @@ export interface ExternalServiceResource {
 }
 
 export interface ExternalServiceResourcePromise extends PromiseLike<ExternalServiceResource> {
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExternalServiceResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExternalServiceResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ExternalServiceResourcePromise;
     withExternalServiceHttpHealthCheck(options?: WithExternalServiceHttpHealthCheckOptions): ExternalServiceResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ExternalServiceResourcePromise;
@@ -17067,8 +17242,8 @@ export interface ExternalServiceResourcePromise extends PromiseLike<ExternalServ
     withExplicitStart(): ExternalServiceResourcePromise;
     withHealthCheck(key: string): ExternalServiceResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ExternalServiceResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExternalServiceResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExternalServiceResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExternalServiceResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExternalServiceResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): ExternalServiceResourcePromise;
     excludeFromMcp(): ExternalServiceResourcePromise;
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ExternalServiceResourcePromise;
@@ -17087,9 +17262,9 @@ export interface ExternalServiceResourcePromise extends PromiseLike<ExternalServ
     withStatus(status: TestResourceStatus): ExternalServiceResourcePromise;
     withNestedConfig(config: TestNestedDto): ExternalServiceResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ExternalServiceResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExternalServiceResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExternalServiceResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExternalServiceResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExternalServiceResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExternalServiceResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExternalServiceResourcePromise;
     withEndpoints(endpoints: string[]): ExternalServiceResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ExternalServiceResourcePromise;
     withMergeLabel(label: string): ExternalServiceResourcePromise;
@@ -17112,7 +17287,8 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     }
 
     /** @internal */
-    private async _withContainerRegistryInternal(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ExternalServiceResource> {
+    private async _withContainerRegistryInternal(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ExternalServiceResource> {
+        registry = isPromiseLike(registry) ? await registry : registry;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, registry };
         const result = await this._client.invokeCapability<ExternalServiceResourceHandle>(
             'Aspire.Hosting/withContainerRegistry',
@@ -17122,8 +17298,8 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withContainerRegistryInternal(registry));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExternalServiceResourcePromise {
+        return new ExternalServiceResourcePromiseImpl(this._withContainerRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -17142,7 +17318,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ExternalServiceResourcePromise {
         const buildImage = options?.buildImage;
         const runtimeImage = options?.runtimeImage;
-        return new ExternalServiceResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage));
+        return new ExternalServiceResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage), this._client);
     }
 
     /** @internal */
@@ -17161,7 +17337,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     withExternalServiceHttpHealthCheck(options?: WithExternalServiceHttpHealthCheckOptions): ExternalServiceResourcePromise {
         const path = options?.path;
         const statusCode = options?.statusCode;
-        return new ExternalServiceResourcePromiseImpl(this._withExternalServiceHttpHealthCheckInternal(path, statusCode));
+        return new ExternalServiceResourcePromiseImpl(this._withExternalServiceHttpHealthCheckInternal(path, statusCode), this._client);
     }
 
     /** @internal */
@@ -17178,7 +17354,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ExternalServiceResourcePromise {
         const helpLink = options?.helpLink;
-        return new ExternalServiceResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink));
+        return new ExternalServiceResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink), this._client);
     }
 
     /** @internal */
@@ -17198,7 +17374,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withUrlsCallbackInternal(callback));
+        return new ExternalServiceResourcePromiseImpl(this._withUrlsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -17215,7 +17391,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): ExternalServiceResourcePromise {
         const displayText = options?.displayText;
-        return new ExternalServiceResourcePromiseImpl(this._withUrlInternal(url, displayText));
+        return new ExternalServiceResourcePromiseImpl(this._withUrlInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -17232,7 +17408,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ExternalServiceResourcePromise {
         const displayText = options?.displayText;
-        return new ExternalServiceResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText));
+        return new ExternalServiceResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -17251,7 +17427,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback));
+        return new ExternalServiceResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -17266,7 +17442,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._excludeFromManifestInternal());
+        return new ExternalServiceResourcePromiseImpl(this._excludeFromManifestInternal(), this._client);
     }
 
     /** @internal */
@@ -17281,7 +17457,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withExplicitStartInternal());
+        return new ExternalServiceResourcePromiseImpl(this._withExplicitStartInternal(), this._client);
     }
 
     /** @internal */
@@ -17296,7 +17472,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Adds a health check by key */
     withHealthCheck(key: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withHealthCheckInternal(key));
+        return new ExternalServiceResourcePromiseImpl(this._withHealthCheckInternal(key), this._client);
     }
 
     /** @internal */
@@ -17318,11 +17494,12 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ExternalServiceResourcePromise {
         const commandOptions = options?.commandOptions;
-        return new ExternalServiceResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions));
+        return new ExternalServiceResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions), this._client);
     }
 
     /** @internal */
-    private async _withParentRelationshipInternal(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ExternalServiceResource> {
+    private async _withParentRelationshipInternal(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ExternalServiceResource> {
+        parent = isPromiseLike(parent) ? await parent : parent;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, parent };
         const result = await this._client.invokeCapability<ExternalServiceResourceHandle>(
             'Aspire.Hosting/withBuilderParentRelationship',
@@ -17332,12 +17509,13 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withParentRelationshipInternal(parent));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExternalServiceResourcePromise {
+        return new ExternalServiceResourcePromiseImpl(this._withParentRelationshipInternal(parent), this._client);
     }
 
     /** @internal */
-    private async _withChildRelationshipInternal(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ExternalServiceResource> {
+    private async _withChildRelationshipInternal(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ExternalServiceResource> {
+        child = isPromiseLike(child) ? await child : child;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, child };
         const result = await this._client.invokeCapability<ExternalServiceResourceHandle>(
             'Aspire.Hosting/withBuilderChildRelationship',
@@ -17347,8 +17525,8 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withChildRelationshipInternal(child));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExternalServiceResourcePromise {
+        return new ExternalServiceResourcePromiseImpl(this._withChildRelationshipInternal(child), this._client);
     }
 
     /** @internal */
@@ -17365,7 +17543,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): ExternalServiceResourcePromise {
         const iconVariant = options?.iconVariant;
-        return new ExternalServiceResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant));
+        return new ExternalServiceResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant), this._client);
     }
 
     /** @internal */
@@ -17380,7 +17558,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._excludeFromMcpInternal());
+        return new ExternalServiceResourcePromiseImpl(this._excludeFromMcpInternal(), this._client);
     }
 
     /** @internal */
@@ -17408,7 +17586,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
         const requiredBy = options?.requiredBy;
         const tags = options?.tags;
         const description = options?.description;
-        return new ExternalServiceResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description));
+        return new ExternalServiceResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description), this._client);
     }
 
     /** @internal */
@@ -17428,7 +17606,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withPipelineConfigurationInternal(callback));
+        return new ExternalServiceResourcePromiseImpl(this._withPipelineConfigurationInternal(callback), this._client);
     }
 
     /** Gets the resource name */
@@ -17457,7 +17635,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback));
+        return new ExternalServiceResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -17477,7 +17655,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._onResourceStoppedInternal(callback));
+        return new ExternalServiceResourcePromiseImpl(this._onResourceStoppedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -17497,7 +17675,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._onInitializeResourceInternal(callback));
+        return new ExternalServiceResourcePromiseImpl(this._onInitializeResourceInternal(callback), this._client);
     }
 
     /** @internal */
@@ -17517,7 +17695,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._onResourceReadyInternal(callback));
+        return new ExternalServiceResourcePromiseImpl(this._onResourceReadyInternal(callback), this._client);
     }
 
     /** @internal */
@@ -17536,7 +17714,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     withOptionalString(options?: WithOptionalStringOptions): ExternalServiceResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new ExternalServiceResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new ExternalServiceResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -17551,7 +17729,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withConfigInternal(config));
+        return new ExternalServiceResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -17566,7 +17744,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new ExternalServiceResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -17581,7 +17759,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new ExternalServiceResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -17596,7 +17774,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new ExternalServiceResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -17618,7 +17796,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ExternalServiceResourcePromise {
         const callback = options?.callback;
-        return new ExternalServiceResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new ExternalServiceResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -17633,7 +17811,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withStatusInternal(status));
+        return new ExternalServiceResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -17648,7 +17826,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new ExternalServiceResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -17668,11 +17846,12 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new ExternalServiceResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ExternalServiceResource> {
+    private async _testWaitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ExternalServiceResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ExternalServiceResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -17682,12 +17861,13 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExternalServiceResourcePromise {
+        return new ExternalServiceResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ExternalServiceResource> {
+    private async _withDependencyInternal(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ExternalServiceResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ExternalServiceResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -17697,12 +17877,13 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExternalServiceResourcePromise {
+        return new ExternalServiceResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ExternalServiceResource> {
+    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ExternalServiceResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ExternalServiceResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -17712,8 +17893,8 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExternalServiceResourcePromise {
+        return new ExternalServiceResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -17728,7 +17909,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new ExternalServiceResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -17747,7 +17928,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new ExternalServiceResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** @internal */
@@ -17762,7 +17943,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new ExternalServiceResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -17777,7 +17958,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new ExternalServiceResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -17792,7 +17973,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new ExternalServiceResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -17807,7 +17988,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new ExternalServiceResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -17826,7 +18007,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ExternalServiceResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ExternalServiceResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new ExternalServiceResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -17845,7 +18026,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ExternalServiceResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ExternalServiceResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new ExternalServiceResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -17860,7 +18041,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new ExternalServiceResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -17875,7 +18056,7 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new ExternalServiceResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -17886,7 +18067,9 @@ class ExternalServiceResourceImpl extends ResourceBuilderBase<ExternalServiceRes
  * await builder.addSomething().withX().withY();
  */
 class ExternalServiceResourcePromiseImpl implements ExternalServiceResourcePromise {
-    constructor(private _promise: Promise<ExternalServiceResource>) {}
+    constructor(private _promise: Promise<ExternalServiceResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ExternalServiceResource, TResult2 = never>(
         onfulfilled?: ((value: ExternalServiceResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -17896,93 +18079,93 @@ class ExternalServiceResourcePromiseImpl implements ExternalServiceResourcePromi
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExternalServiceResourcePromise {
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)), this._client);
     }
 
     /** Sets the base image for a Dockerfile build */
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)), this._client);
     }
 
     /** Adds an HTTP health check to an external service */
     withExternalServiceHttpHealthCheck(options?: WithExternalServiceHttpHealthCheckOptions): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withExternalServiceHttpHealthCheck(options)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withExternalServiceHttpHealthCheck(options)), this._client);
     }
 
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)), this._client);
     }
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)), this._client);
     }
 
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)), this._client);
     }
 
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)), this._client);
     }
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)), this._client);
     }
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()), this._client);
     }
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()), this._client);
     }
 
     /** Adds a health check by key */
     withHealthCheck(key: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)), this._client);
     }
 
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)), this._client);
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExternalServiceResourcePromise {
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)), this._client);
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExternalServiceResourcePromise {
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)), this._client);
     }
 
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)), this._client);
     }
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()), this._client);
     }
 
     /** Adds a pipeline step to the resource */
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)), this._client);
     }
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)), this._client);
     }
 
     /** Gets the resource name */
@@ -17992,132 +18175,132 @@ class ExternalServiceResourcePromiseImpl implements ExternalServiceResourcePromi
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)), this._client);
     }
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)), this._client);
     }
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)), this._client);
     }
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)), this._client);
     }
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ExternalServiceResourcePromise {
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExternalServiceResourcePromise {
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ExternalServiceResourcePromise {
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ExternalServiceResourcePromise {
-        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new ExternalServiceResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -18128,7 +18311,7 @@ class ExternalServiceResourcePromiseImpl implements ExternalServiceResourcePromi
 
 export interface ParameterResource {
     toJSON(): MarshalledHandle;
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ParameterResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ParameterResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ParameterResourcePromise;
     withDescription(description: string, options?: WithDescriptionOptions): ParameterResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ParameterResourcePromise;
@@ -18140,8 +18323,8 @@ export interface ParameterResource {
     withExplicitStart(): ParameterResourcePromise;
     withHealthCheck(key: string): ParameterResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ParameterResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ParameterResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ParameterResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ParameterResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ParameterResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): ParameterResourcePromise;
     excludeFromMcp(): ParameterResourcePromise;
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ParameterResourcePromise;
@@ -18160,9 +18343,9 @@ export interface ParameterResource {
     withStatus(status: TestResourceStatus): ParameterResourcePromise;
     withNestedConfig(config: TestNestedDto): ParameterResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ParameterResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ParameterResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ParameterResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ParameterResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ParameterResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ParameterResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ParameterResourcePromise;
     withEndpoints(endpoints: string[]): ParameterResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ParameterResourcePromise;
     withMergeLabel(label: string): ParameterResourcePromise;
@@ -18176,7 +18359,7 @@ export interface ParameterResource {
 }
 
 export interface ParameterResourcePromise extends PromiseLike<ParameterResource> {
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ParameterResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ParameterResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ParameterResourcePromise;
     withDescription(description: string, options?: WithDescriptionOptions): ParameterResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ParameterResourcePromise;
@@ -18188,8 +18371,8 @@ export interface ParameterResourcePromise extends PromiseLike<ParameterResource>
     withExplicitStart(): ParameterResourcePromise;
     withHealthCheck(key: string): ParameterResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ParameterResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ParameterResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ParameterResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ParameterResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ParameterResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): ParameterResourcePromise;
     excludeFromMcp(): ParameterResourcePromise;
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ParameterResourcePromise;
@@ -18208,9 +18391,9 @@ export interface ParameterResourcePromise extends PromiseLike<ParameterResource>
     withStatus(status: TestResourceStatus): ParameterResourcePromise;
     withNestedConfig(config: TestNestedDto): ParameterResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ParameterResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ParameterResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ParameterResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ParameterResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ParameterResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ParameterResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ParameterResourcePromise;
     withEndpoints(endpoints: string[]): ParameterResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ParameterResourcePromise;
     withMergeLabel(label: string): ParameterResourcePromise;
@@ -18233,7 +18416,8 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     }
 
     /** @internal */
-    private async _withContainerRegistryInternal(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ParameterResource> {
+    private async _withContainerRegistryInternal(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ParameterResource> {
+        registry = isPromiseLike(registry) ? await registry : registry;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, registry };
         const result = await this._client.invokeCapability<ParameterResourceHandle>(
             'Aspire.Hosting/withContainerRegistry',
@@ -18243,8 +18427,8 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withContainerRegistryInternal(registry));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ParameterResourcePromise {
+        return new ParameterResourcePromiseImpl(this._withContainerRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -18263,7 +18447,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ParameterResourcePromise {
         const buildImage = options?.buildImage;
         const runtimeImage = options?.runtimeImage;
-        return new ParameterResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage));
+        return new ParameterResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage), this._client);
     }
 
     /** @internal */
@@ -18280,7 +18464,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     /** Sets a parameter description */
     withDescription(description: string, options?: WithDescriptionOptions): ParameterResourcePromise {
         const enableMarkdown = options?.enableMarkdown;
-        return new ParameterResourcePromiseImpl(this._withDescriptionInternal(description, enableMarkdown));
+        return new ParameterResourcePromiseImpl(this._withDescriptionInternal(description, enableMarkdown), this._client);
     }
 
     /** @internal */
@@ -18297,7 +18481,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ParameterResourcePromise {
         const helpLink = options?.helpLink;
-        return new ParameterResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink));
+        return new ParameterResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink), this._client);
     }
 
     /** @internal */
@@ -18317,7 +18501,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withUrlsCallbackInternal(callback));
+        return new ParameterResourcePromiseImpl(this._withUrlsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -18334,7 +18518,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): ParameterResourcePromise {
         const displayText = options?.displayText;
-        return new ParameterResourcePromiseImpl(this._withUrlInternal(url, displayText));
+        return new ParameterResourcePromiseImpl(this._withUrlInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -18351,7 +18535,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ParameterResourcePromise {
         const displayText = options?.displayText;
-        return new ParameterResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText));
+        return new ParameterResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -18370,7 +18554,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback));
+        return new ParameterResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -18385,7 +18569,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._excludeFromManifestInternal());
+        return new ParameterResourcePromiseImpl(this._excludeFromManifestInternal(), this._client);
     }
 
     /** @internal */
@@ -18400,7 +18584,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withExplicitStartInternal());
+        return new ParameterResourcePromiseImpl(this._withExplicitStartInternal(), this._client);
     }
 
     /** @internal */
@@ -18415,7 +18599,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Adds a health check by key */
     withHealthCheck(key: string): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withHealthCheckInternal(key));
+        return new ParameterResourcePromiseImpl(this._withHealthCheckInternal(key), this._client);
     }
 
     /** @internal */
@@ -18437,11 +18621,12 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ParameterResourcePromise {
         const commandOptions = options?.commandOptions;
-        return new ParameterResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions));
+        return new ParameterResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions), this._client);
     }
 
     /** @internal */
-    private async _withParentRelationshipInternal(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ParameterResource> {
+    private async _withParentRelationshipInternal(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ParameterResource> {
+        parent = isPromiseLike(parent) ? await parent : parent;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, parent };
         const result = await this._client.invokeCapability<ParameterResourceHandle>(
             'Aspire.Hosting/withBuilderParentRelationship',
@@ -18451,12 +18636,13 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withParentRelationshipInternal(parent));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ParameterResourcePromise {
+        return new ParameterResourcePromiseImpl(this._withParentRelationshipInternal(parent), this._client);
     }
 
     /** @internal */
-    private async _withChildRelationshipInternal(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ParameterResource> {
+    private async _withChildRelationshipInternal(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ParameterResource> {
+        child = isPromiseLike(child) ? await child : child;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, child };
         const result = await this._client.invokeCapability<ParameterResourceHandle>(
             'Aspire.Hosting/withBuilderChildRelationship',
@@ -18466,8 +18652,8 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withChildRelationshipInternal(child));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ParameterResourcePromise {
+        return new ParameterResourcePromiseImpl(this._withChildRelationshipInternal(child), this._client);
     }
 
     /** @internal */
@@ -18484,7 +18670,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): ParameterResourcePromise {
         const iconVariant = options?.iconVariant;
-        return new ParameterResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant));
+        return new ParameterResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant), this._client);
     }
 
     /** @internal */
@@ -18499,7 +18685,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._excludeFromMcpInternal());
+        return new ParameterResourcePromiseImpl(this._excludeFromMcpInternal(), this._client);
     }
 
     /** @internal */
@@ -18527,7 +18713,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
         const requiredBy = options?.requiredBy;
         const tags = options?.tags;
         const description = options?.description;
-        return new ParameterResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description));
+        return new ParameterResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description), this._client);
     }
 
     /** @internal */
@@ -18547,7 +18733,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withPipelineConfigurationInternal(callback));
+        return new ParameterResourcePromiseImpl(this._withPipelineConfigurationInternal(callback), this._client);
     }
 
     /** Gets the resource name */
@@ -18576,7 +18762,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback));
+        return new ParameterResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -18596,7 +18782,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._onResourceStoppedInternal(callback));
+        return new ParameterResourcePromiseImpl(this._onResourceStoppedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -18616,7 +18802,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._onInitializeResourceInternal(callback));
+        return new ParameterResourcePromiseImpl(this._onInitializeResourceInternal(callback), this._client);
     }
 
     /** @internal */
@@ -18636,7 +18822,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._onResourceReadyInternal(callback));
+        return new ParameterResourcePromiseImpl(this._onResourceReadyInternal(callback), this._client);
     }
 
     /** @internal */
@@ -18655,7 +18841,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     withOptionalString(options?: WithOptionalStringOptions): ParameterResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new ParameterResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new ParameterResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -18670,7 +18856,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withConfigInternal(config));
+        return new ParameterResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -18685,7 +18871,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new ParameterResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -18700,7 +18886,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new ParameterResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -18715,7 +18901,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new ParameterResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -18737,7 +18923,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ParameterResourcePromise {
         const callback = options?.callback;
-        return new ParameterResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new ParameterResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -18752,7 +18938,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withStatusInternal(status));
+        return new ParameterResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -18767,7 +18953,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new ParameterResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -18787,11 +18973,12 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new ParameterResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ParameterResource> {
+    private async _testWaitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ParameterResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ParameterResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -18801,12 +18988,13 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ParameterResourcePromise {
+        return new ParameterResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ParameterResource> {
+    private async _withDependencyInternal(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ParameterResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ParameterResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -18816,12 +19004,13 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ParameterResourcePromise {
+        return new ParameterResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ParameterResource> {
+    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ParameterResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ParameterResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -18831,8 +19020,8 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ParameterResourcePromise {
+        return new ParameterResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -18847,7 +19036,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new ParameterResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -18866,7 +19055,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new ParameterResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** @internal */
@@ -18881,7 +19070,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new ParameterResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -18896,7 +19085,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new ParameterResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -18911,7 +19100,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new ParameterResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -18926,7 +19115,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new ParameterResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -18945,7 +19134,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ParameterResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ParameterResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new ParameterResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -18964,7 +19153,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ParameterResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ParameterResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new ParameterResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -18979,7 +19168,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new ParameterResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -18994,7 +19183,7 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new ParameterResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -19005,7 +19194,9 @@ class ParameterResourceImpl extends ResourceBuilderBase<ParameterResourceHandle>
  * await builder.addSomething().withX().withY();
  */
 class ParameterResourcePromiseImpl implements ParameterResourcePromise {
-    constructor(private _promise: Promise<ParameterResource>) {}
+    constructor(private _promise: Promise<ParameterResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ParameterResource, TResult2 = never>(
         onfulfilled?: ((value: ParameterResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -19015,93 +19206,93 @@ class ParameterResourcePromiseImpl implements ParameterResourcePromise {
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ParameterResourcePromise {
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)), this._client);
     }
 
     /** Sets the base image for a Dockerfile build */
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)), this._client);
     }
 
     /** Sets a parameter description */
     withDescription(description: string, options?: WithDescriptionOptions): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withDescription(description, options)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withDescription(description, options)), this._client);
     }
 
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)), this._client);
     }
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)), this._client);
     }
 
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)), this._client);
     }
 
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)), this._client);
     }
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)), this._client);
     }
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()), this._client);
     }
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()), this._client);
     }
 
     /** Adds a health check by key */
     withHealthCheck(key: string): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)), this._client);
     }
 
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)), this._client);
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ParameterResourcePromise {
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)), this._client);
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ParameterResourcePromise {
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)), this._client);
     }
 
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)), this._client);
     }
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()), this._client);
     }
 
     /** Adds a pipeline step to the resource */
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)), this._client);
     }
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)), this._client);
     }
 
     /** Gets the resource name */
@@ -19111,132 +19302,132 @@ class ParameterResourcePromiseImpl implements ParameterResourcePromise {
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)), this._client);
     }
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)), this._client);
     }
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)), this._client);
     }
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)), this._client);
     }
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ParameterResourcePromise {
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ParameterResourcePromise {
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ParameterResourcePromise {
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ParameterResourcePromise {
-        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new ParameterResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -19247,7 +19438,7 @@ class ParameterResourcePromiseImpl implements ParameterResourcePromise {
 
 export interface ProjectResource {
     toJSON(): MarshalledHandle;
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ProjectResourcePromise;
     withMcpServer(options?: WithMcpServerOptions): ProjectResourcePromise;
     withOtlpExporter(): ProjectResourcePromise;
@@ -19256,18 +19447,18 @@ export interface ProjectResource {
     disableForwardedHeaders(): ProjectResourcePromise;
     publishAsDockerFile(options?: PublishAsDockerFileOptions): ProjectResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ProjectResourcePromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): ProjectResourcePromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): ProjectResourcePromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): ProjectResourcePromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): ProjectResourcePromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): ProjectResourcePromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): ProjectResourcePromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ProjectResourcePromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): ProjectResourcePromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): ProjectResourcePromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ProjectResourcePromise;
     withArgs(args: string[]): ProjectResourcePromise;
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): ProjectResourcePromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): ProjectResourcePromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): ProjectResourcePromise;
     withReferenceUri(name: string, uri: string): ProjectResourcePromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): ProjectResourcePromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): ProjectResourcePromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): ProjectResourcePromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): ProjectResourcePromise;
     withEndpoint(options?: WithEndpointOptions): ProjectResourcePromise;
     withHttpEndpoint(options?: WithHttpEndpointOptions): ProjectResourcePromise;
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): ProjectResourcePromise;
@@ -19279,14 +19470,14 @@ export interface ProjectResource {
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ProjectResourcePromise;
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ProjectResourcePromise;
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): ProjectResourcePromise;
-    publishWithContainerFiles(source: ResourceWithContainerFiles, destinationPath: string): ProjectResourcePromise;
+    publishWithContainerFiles(source: Awaitable<ResourceWithContainerFiles>, destinationPath: string): ProjectResourcePromise;
     excludeFromManifest(): ProjectResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ProjectResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ProjectResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ProjectResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ProjectResourcePromise;
     withExplicitStart(): ProjectResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ProjectResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ProjectResourcePromise;
     withHealthCheck(key: string): ProjectResourcePromise;
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): ProjectResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ProjectResourcePromise;
@@ -19294,8 +19485,8 @@ export interface ProjectResource {
     withCertificateTrustScope(scope: CertificateTrustScope): ProjectResourcePromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): ProjectResourcePromise;
     withoutHttpsCertificate(): ProjectResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): ProjectResourcePromise;
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): ProjectResourcePromise;
     excludeFromMcp(): ProjectResourcePromise;
@@ -19319,9 +19510,9 @@ export interface ProjectResource {
     withStatus(status: TestResourceStatus): ProjectResourcePromise;
     withNestedConfig(config: TestNestedDto): ProjectResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ProjectResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ProjectResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ProjectResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ProjectResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ProjectResourcePromise;
     withEndpoints(endpoints: string[]): ProjectResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): ProjectResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ProjectResourcePromise;
@@ -19336,7 +19527,7 @@ export interface ProjectResource {
 }
 
 export interface ProjectResourcePromise extends PromiseLike<ProjectResource> {
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ProjectResourcePromise;
     withMcpServer(options?: WithMcpServerOptions): ProjectResourcePromise;
     withOtlpExporter(): ProjectResourcePromise;
@@ -19345,18 +19536,18 @@ export interface ProjectResourcePromise extends PromiseLike<ProjectResource> {
     disableForwardedHeaders(): ProjectResourcePromise;
     publishAsDockerFile(options?: PublishAsDockerFileOptions): ProjectResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ProjectResourcePromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): ProjectResourcePromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): ProjectResourcePromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): ProjectResourcePromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): ProjectResourcePromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): ProjectResourcePromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): ProjectResourcePromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ProjectResourcePromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): ProjectResourcePromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): ProjectResourcePromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ProjectResourcePromise;
     withArgs(args: string[]): ProjectResourcePromise;
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): ProjectResourcePromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): ProjectResourcePromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): ProjectResourcePromise;
     withReferenceUri(name: string, uri: string): ProjectResourcePromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): ProjectResourcePromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): ProjectResourcePromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): ProjectResourcePromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): ProjectResourcePromise;
     withEndpoint(options?: WithEndpointOptions): ProjectResourcePromise;
     withHttpEndpoint(options?: WithHttpEndpointOptions): ProjectResourcePromise;
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): ProjectResourcePromise;
@@ -19368,14 +19559,14 @@ export interface ProjectResourcePromise extends PromiseLike<ProjectResource> {
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ProjectResourcePromise;
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ProjectResourcePromise;
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): ProjectResourcePromise;
-    publishWithContainerFiles(source: ResourceWithContainerFiles, destinationPath: string): ProjectResourcePromise;
+    publishWithContainerFiles(source: Awaitable<ResourceWithContainerFiles>, destinationPath: string): ProjectResourcePromise;
     excludeFromManifest(): ProjectResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ProjectResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ProjectResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ProjectResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ProjectResourcePromise;
     withExplicitStart(): ProjectResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ProjectResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ProjectResourcePromise;
     withHealthCheck(key: string): ProjectResourcePromise;
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): ProjectResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ProjectResourcePromise;
@@ -19383,8 +19574,8 @@ export interface ProjectResourcePromise extends PromiseLike<ProjectResource> {
     withCertificateTrustScope(scope: CertificateTrustScope): ProjectResourcePromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): ProjectResourcePromise;
     withoutHttpsCertificate(): ProjectResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): ProjectResourcePromise;
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): ProjectResourcePromise;
     excludeFromMcp(): ProjectResourcePromise;
@@ -19408,9 +19599,9 @@ export interface ProjectResourcePromise extends PromiseLike<ProjectResource> {
     withStatus(status: TestResourceStatus): ProjectResourcePromise;
     withNestedConfig(config: TestNestedDto): ProjectResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ProjectResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ProjectResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ProjectResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ProjectResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ProjectResourcePromise;
     withEndpoints(endpoints: string[]): ProjectResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): ProjectResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ProjectResourcePromise;
@@ -19434,7 +19625,8 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** @internal */
-    private async _withContainerRegistryInternal(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ProjectResource> {
+    private async _withContainerRegistryInternal(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ProjectResource> {
+        registry = isPromiseLike(registry) ? await registry : registry;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, registry };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting/withContainerRegistry',
@@ -19444,8 +19636,8 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withContainerRegistryInternal(registry));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._withContainerRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -19464,7 +19656,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ProjectResourcePromise {
         const buildImage = options?.buildImage;
         const runtimeImage = options?.runtimeImage;
-        return new ProjectResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage));
+        return new ProjectResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage), this._client);
     }
 
     /** @internal */
@@ -19483,7 +19675,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     withMcpServer(options?: WithMcpServerOptions): ProjectResourcePromise {
         const path = options?.path;
         const endpointName = options?.endpointName;
-        return new ProjectResourcePromiseImpl(this._withMcpServerInternal(path, endpointName));
+        return new ProjectResourcePromiseImpl(this._withMcpServerInternal(path, endpointName), this._client);
     }
 
     /** @internal */
@@ -19498,7 +19690,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withOtlpExporterInternal());
+        return new ProjectResourcePromiseImpl(this._withOtlpExporterInternal(), this._client);
     }
 
     /** @internal */
@@ -19513,7 +19705,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withOtlpExporterProtocolInternal(protocol));
+        return new ProjectResourcePromiseImpl(this._withOtlpExporterProtocolInternal(protocol), this._client);
     }
 
     /** @internal */
@@ -19528,7 +19720,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Sets the number of replicas */
     withReplicas(replicas: number): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withReplicasInternal(replicas));
+        return new ProjectResourcePromiseImpl(this._withReplicasInternal(replicas), this._client);
     }
 
     /** @internal */
@@ -19543,7 +19735,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Disables forwarded headers for the project */
     disableForwardedHeaders(): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._disableForwardedHeadersInternal());
+        return new ProjectResourcePromiseImpl(this._disableForwardedHeadersInternal(), this._client);
     }
 
     /** @internal */
@@ -19565,7 +19757,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     /** Publishes a project as a Docker file with optional container configuration */
     publishAsDockerFile(options?: PublishAsDockerFileOptions): ProjectResourcePromise {
         const configure = options?.configure;
-        return new ProjectResourcePromiseImpl(this._publishAsDockerFileInternal(configure));
+        return new ProjectResourcePromiseImpl(this._publishAsDockerFileInternal(configure), this._client);
     }
 
     /** @internal */
@@ -19582,11 +19774,12 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ProjectResourcePromise {
         const helpLink = options?.helpLink;
-        return new ProjectResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink));
+        return new ProjectResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): Promise<ProjectResource> {
+    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): Promise<ProjectResource> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting/withEnvironment',
@@ -19596,8 +19789,8 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withEnvironmentInternal(name, value));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._withEnvironmentInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -19615,7 +19808,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withEnvironmentExpressionInternal(name, value));
+        return new ProjectResourcePromiseImpl(this._withEnvironmentExpressionInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -19635,11 +19828,12 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withEnvironmentCallbackInternal(callback));
+        return new ProjectResourcePromiseImpl(this._withEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentEndpointInternal(name: string, endpointReference: EndpointReference): Promise<ProjectResource> {
+    private async _withEnvironmentEndpointInternal(name: string, endpointReference: Awaitable<EndpointReference>): Promise<ProjectResource> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, endpointReference };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting/withEnvironmentEndpoint',
@@ -19652,12 +19846,13 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentParameterInternal(name: string, parameter: ParameterResource): Promise<ProjectResource> {
+    private async _withEnvironmentParameterInternal(name: string, parameter: Awaitable<ParameterResource>): Promise<ProjectResource> {
+        parameter = isPromiseLike(parameter) ? await parameter : parameter;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, parameter };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting/withEnvironmentParameter',
@@ -19670,12 +19865,13 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withEnvironmentParameterInternal(name, parameter));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._withEnvironmentParameterInternal(name, parameter), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ProjectResource> {
+    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ProjectResource> {
+        resource = isPromiseLike(resource) ? await resource : resource;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, envVarName, resource };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting/withEnvironmentConnectionString',
@@ -19688,8 +19884,8 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource), this._client);
     }
 
     /** @internal */
@@ -19704,7 +19900,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Adds arguments */
     withArgs(args: string[]): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withArgsInternal(args));
+        return new ProjectResourcePromiseImpl(this._withArgsInternal(args), this._client);
     }
 
     /** @internal */
@@ -19724,11 +19920,12 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withArgsCallbackInternal(callback));
+        return new ProjectResourcePromiseImpl(this._withArgsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withReferenceInternal(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, connectionName?: string, optional?: boolean, name?: string): Promise<ProjectResource> {
+    private async _withReferenceInternal(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, connectionName?: string, optional?: boolean, name?: string): Promise<ProjectResource> {
+        source = isPromiseLike(source) ? await source : source;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, source };
         if (connectionName !== undefined) rpcArgs.connectionName = connectionName;
         if (optional !== undefined) rpcArgs.optional = optional;
@@ -19741,11 +19938,11 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): ProjectResourcePromise {
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): ProjectResourcePromise {
         const connectionName = options?.connectionName;
         const optional = options?.optional;
         const name = options?.name;
-        return new ProjectResourcePromiseImpl(this._withReferenceInternal(source, connectionName, optional, name));
+        return new ProjectResourcePromiseImpl(this._withReferenceInternal(source, connectionName, optional, name), this._client);
     }
 
     /** @internal */
@@ -19760,11 +19957,12 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withReferenceUriInternal(name, uri));
+        return new ProjectResourcePromiseImpl(this._withReferenceUriInternal(name, uri), this._client);
     }
 
     /** @internal */
-    private async _withReferenceExternalServiceInternal(externalService: ExternalServiceResource): Promise<ProjectResource> {
+    private async _withReferenceExternalServiceInternal(externalService: Awaitable<ExternalServiceResource>): Promise<ProjectResource> {
+        externalService = isPromiseLike(externalService) ? await externalService : externalService;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, externalService };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting/withReferenceExternalService',
@@ -19774,12 +19972,13 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withReferenceExternalServiceInternal(externalService));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._withReferenceExternalServiceInternal(externalService), this._client);
     }
 
     /** @internal */
-    private async _withReferenceEndpointInternal(endpointReference: EndpointReference): Promise<ProjectResource> {
+    private async _withReferenceEndpointInternal(endpointReference: Awaitable<EndpointReference>): Promise<ProjectResource> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, endpointReference };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting/withReferenceEndpoint',
@@ -19789,8 +19988,8 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withReferenceEndpointInternal(endpointReference));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._withReferenceEndpointInternal(endpointReference), this._client);
     }
 
     /** @internal */
@@ -19821,7 +20020,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
         const isProxied = options?.isProxied;
         const isExternal = options?.isExternal;
         const protocol = options?.protocol;
-        return new ProjectResourcePromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol));
+        return new ProjectResourcePromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol), this._client);
     }
 
     /** @internal */
@@ -19846,7 +20045,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new ProjectResourcePromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied));
+        return new ProjectResourcePromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -19871,7 +20070,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new ProjectResourcePromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied));
+        return new ProjectResourcePromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -19886,7 +20085,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withExternalHttpEndpointsInternal());
+        return new ProjectResourcePromiseImpl(this._withExternalHttpEndpointsInternal(), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -19910,7 +20109,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._asHttp2ServiceInternal());
+        return new ProjectResourcePromiseImpl(this._asHttp2ServiceInternal(), this._client);
     }
 
     /** @internal */
@@ -19930,7 +20129,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withUrlsCallbackInternal(callback));
+        return new ProjectResourcePromiseImpl(this._withUrlsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -19947,7 +20146,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): ProjectResourcePromise {
         const displayText = options?.displayText;
-        return new ProjectResourcePromiseImpl(this._withUrlInternal(url, displayText));
+        return new ProjectResourcePromiseImpl(this._withUrlInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -19964,7 +20163,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ProjectResourcePromise {
         const displayText = options?.displayText;
-        return new ProjectResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText));
+        return new ProjectResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -19983,7 +20182,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback));
+        return new ProjectResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -20003,11 +20202,12 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback));
+        return new ProjectResourcePromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
-    private async _publishWithContainerFilesInternal(source: ResourceWithContainerFiles, destinationPath: string): Promise<ProjectResource> {
+    private async _publishWithContainerFilesInternal(source: Awaitable<ResourceWithContainerFiles>, destinationPath: string): Promise<ProjectResource> {
+        source = isPromiseLike(source) ? await source : source;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, source, destinationPath };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting/publishWithContainerFilesFromResource',
@@ -20017,8 +20217,8 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** Configures the resource to copy container files from the specified source during publishing */
-    publishWithContainerFiles(source: ResourceWithContainerFiles, destinationPath: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._publishWithContainerFilesInternal(source, destinationPath));
+    publishWithContainerFiles(source: Awaitable<ResourceWithContainerFiles>, destinationPath: string): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._publishWithContainerFilesInternal(source, destinationPath), this._client);
     }
 
     /** @internal */
@@ -20033,11 +20233,12 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._excludeFromManifestInternal());
+        return new ProjectResourcePromiseImpl(this._excludeFromManifestInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ProjectResource> {
+    private async _waitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ProjectResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting/waitForResource',
@@ -20047,12 +20248,13 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._waitForInternal(dependency));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._waitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<ProjectResource> {
+    private async _waitForWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<ProjectResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting/waitForWithBehavior',
@@ -20062,12 +20264,13 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
-    private async _waitForStartInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ProjectResource> {
+    private async _waitForStartInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ProjectResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting/waitForResourceStart',
@@ -20077,12 +20280,13 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._waitForStartInternal(dependency));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._waitForStartInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForStartWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<ProjectResource> {
+    private async _waitForStartWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<ProjectResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting/waitForStartWithBehavior',
@@ -20092,8 +20296,8 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
@@ -20108,11 +20312,12 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withExplicitStartInternal());
+        return new ProjectResourcePromiseImpl(this._withExplicitStartInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForCompletionInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, exitCode?: number): Promise<ProjectResource> {
+    private async _waitForCompletionInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, exitCode?: number): Promise<ProjectResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         if (exitCode !== undefined) rpcArgs.exitCode = exitCode;
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
@@ -20123,9 +20328,9 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ProjectResourcePromise {
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ProjectResourcePromise {
         const exitCode = options?.exitCode;
-        return new ProjectResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode));
+        return new ProjectResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode), this._client);
     }
 
     /** @internal */
@@ -20140,7 +20345,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Adds a health check by key */
     withHealthCheck(key: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withHealthCheckInternal(key));
+        return new ProjectResourcePromiseImpl(this._withHealthCheckInternal(key), this._client);
     }
 
     /** @internal */
@@ -20161,7 +20366,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
         const path = options?.path;
         const statusCode = options?.statusCode;
         const endpointName = options?.endpointName;
-        return new ProjectResourcePromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName));
+        return new ProjectResourcePromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName), this._client);
     }
 
     /** @internal */
@@ -20183,7 +20388,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ProjectResourcePromise {
         const commandOptions = options?.commandOptions;
-        return new ProjectResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions));
+        return new ProjectResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions), this._client);
     }
 
     /** @internal */
@@ -20198,7 +20403,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withDeveloperCertificateTrustInternal(trust));
+        return new ProjectResourcePromiseImpl(this._withDeveloperCertificateTrustInternal(trust), this._client);
     }
 
     /** @internal */
@@ -20213,11 +20418,12 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withCertificateTrustScopeInternal(scope));
+        return new ProjectResourcePromiseImpl(this._withCertificateTrustScopeInternal(scope), this._client);
     }
 
     /** @internal */
-    private async _withHttpsDeveloperCertificateInternal(password?: ParameterResource): Promise<ProjectResource> {
+    private async _withHttpsDeveloperCertificateInternal(password?: Awaitable<ParameterResource>): Promise<ProjectResource> {
+        password = isPromiseLike(password) ? await password : password;
         const rpcArgs: Record<string, unknown> = { builder: this._handle };
         if (password !== undefined) rpcArgs.password = password;
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
@@ -20229,8 +20435,8 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): ProjectResourcePromise {
-        const password = options?.password;
-        return new ProjectResourcePromiseImpl(this._withHttpsDeveloperCertificateInternal(password));
+        let password = options?.password;
+        return new ProjectResourcePromiseImpl(this._withHttpsDeveloperCertificateInternal(password), this._client);
     }
 
     /** @internal */
@@ -20245,11 +20451,12 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withoutHttpsCertificateInternal());
+        return new ProjectResourcePromiseImpl(this._withoutHttpsCertificateInternal(), this._client);
     }
 
     /** @internal */
-    private async _withParentRelationshipInternal(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ProjectResource> {
+    private async _withParentRelationshipInternal(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ProjectResource> {
+        parent = isPromiseLike(parent) ? await parent : parent;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, parent };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting/withBuilderParentRelationship',
@@ -20259,12 +20466,13 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withParentRelationshipInternal(parent));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._withParentRelationshipInternal(parent), this._client);
     }
 
     /** @internal */
-    private async _withChildRelationshipInternal(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ProjectResource> {
+    private async _withChildRelationshipInternal(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ProjectResource> {
+        child = isPromiseLike(child) ? await child : child;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, child };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting/withBuilderChildRelationship',
@@ -20274,8 +20482,8 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withChildRelationshipInternal(child));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._withChildRelationshipInternal(child), this._client);
     }
 
     /** @internal */
@@ -20292,7 +20500,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): ProjectResourcePromise {
         const iconVariant = options?.iconVariant;
-        return new ProjectResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant));
+        return new ProjectResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant), this._client);
     }
 
     /** @internal */
@@ -20321,7 +20529,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
         const failureThreshold = options?.failureThreshold;
         const successThreshold = options?.successThreshold;
         const endpointName = options?.endpointName;
-        return new ProjectResourcePromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName));
+        return new ProjectResourcePromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName), this._client);
     }
 
     /** @internal */
@@ -20336,7 +20544,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._excludeFromMcpInternal());
+        return new ProjectResourcePromiseImpl(this._excludeFromMcpInternal(), this._client);
     }
 
     /** @internal */
@@ -20351,7 +20559,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName));
+        return new ProjectResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName), this._client);
     }
 
     /** @internal */
@@ -20366,7 +20574,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag));
+        return new ProjectResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag), this._client);
     }
 
     /** @internal */
@@ -20394,7 +20602,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
         const requiredBy = options?.requiredBy;
         const tags = options?.tags;
         const description = options?.description;
-        return new ProjectResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description));
+        return new ProjectResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description), this._client);
     }
 
     /** @internal */
@@ -20414,7 +20622,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withPipelineConfigurationInternal(callback));
+        return new ProjectResourcePromiseImpl(this._withPipelineConfigurationInternal(callback), this._client);
     }
 
     /** Gets the resource name */
@@ -20443,7 +20651,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback));
+        return new ProjectResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -20463,7 +20671,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._onResourceStoppedInternal(callback));
+        return new ProjectResourcePromiseImpl(this._onResourceStoppedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -20483,7 +20691,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._onInitializeResourceInternal(callback));
+        return new ProjectResourcePromiseImpl(this._onInitializeResourceInternal(callback), this._client);
     }
 
     /** @internal */
@@ -20503,7 +20711,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._onResourceEndpointsAllocatedInternal(callback));
+        return new ProjectResourcePromiseImpl(this._onResourceEndpointsAllocatedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -20523,7 +20731,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._onResourceReadyInternal(callback));
+        return new ProjectResourcePromiseImpl(this._onResourceReadyInternal(callback), this._client);
     }
 
     /** @internal */
@@ -20542,7 +20750,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     withOptionalString(options?: WithOptionalStringOptions): ProjectResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new ProjectResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new ProjectResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -20557,7 +20765,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withConfigInternal(config));
+        return new ProjectResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -20577,7 +20785,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback));
+        return new ProjectResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -20592,7 +20800,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new ProjectResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -20607,7 +20815,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new ProjectResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -20622,7 +20830,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new ProjectResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -20644,7 +20852,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ProjectResourcePromise {
         const callback = options?.callback;
-        return new ProjectResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new ProjectResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -20659,7 +20867,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withStatusInternal(status));
+        return new ProjectResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -20674,7 +20882,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new ProjectResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -20694,11 +20902,12 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new ProjectResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ProjectResource> {
+    private async _testWaitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ProjectResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -20708,12 +20917,13 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ProjectResource> {
+    private async _withDependencyInternal(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ProjectResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -20723,12 +20933,13 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ProjectResource> {
+    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ProjectResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<ProjectResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -20738,8 +20949,8 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -20754,7 +20965,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new ProjectResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -20769,7 +20980,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables));
+        return new ProjectResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables), this._client);
     }
 
     /** @internal */
@@ -20788,7 +20999,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new ProjectResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** @internal */
@@ -20803,7 +21014,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new ProjectResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -20818,7 +21029,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new ProjectResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -20833,7 +21044,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new ProjectResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -20848,7 +21059,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new ProjectResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -20867,7 +21078,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ProjectResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ProjectResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new ProjectResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -20886,7 +21097,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ProjectResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ProjectResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new ProjectResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -20901,7 +21112,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new ProjectResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -20916,7 +21127,7 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new ProjectResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -20927,7 +21138,9 @@ class ProjectResourceImpl extends ResourceBuilderBase<ProjectResourceHandle> imp
  * await builder.addSomething().withX().withY();
  */
 class ProjectResourcePromiseImpl implements ProjectResourcePromise {
-    constructor(private _promise: Promise<ProjectResource>) {}
+    constructor(private _promise: Promise<ProjectResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ProjectResource, TResult2 = never>(
         onfulfilled?: ((value: ProjectResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -20937,53 +21150,53 @@ class ProjectResourcePromiseImpl implements ProjectResourcePromise {
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)), this._client);
     }
 
     /** Sets the base image for a Dockerfile build */
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)), this._client);
     }
 
     /** Configures an MCP server endpoint on the resource */
     withMcpServer(options?: WithMcpServerOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMcpServer(options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMcpServer(options)), this._client);
     }
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporter()));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporter()), this._client);
     }
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)), this._client);
     }
 
     /** Sets the number of replicas */
     withReplicas(replicas: number): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withReplicas(replicas)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withReplicas(replicas)), this._client);
     }
 
     /** Disables forwarded headers for the project */
     disableForwardedHeaders(): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.disableForwardedHeaders()));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.disableForwardedHeaders()), this._client);
     }
 
     /** Publishes a project as a Docker file with optional container configuration */
     publishAsDockerFile(options?: PublishAsDockerFileOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.publishAsDockerFile(options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.publishAsDockerFile(options)), this._client);
     }
 
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)), this._client);
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)), this._client);
     }
 
     /**
@@ -20991,86 +21204,86 @@ class ProjectResourcePromiseImpl implements ProjectResourcePromise {
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)), this._client);
     }
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)), this._client);
     }
 
     /**
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)), this._client);
     }
 
     /**
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)), this._client);
     }
 
     /**
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)), this._client);
     }
 
     /** Adds arguments */
     withArgs(args: string[]): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withArgs(args)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withArgs(args)), this._client);
     }
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)), this._client);
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withReference(source, options)));
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withReference(source, options)), this._client);
     }
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)), this._client);
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)), this._client);
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)), this._client);
     }
 
     /** Adds a network endpoint */
     withEndpoint(options?: WithEndpointOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEndpoint(options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEndpoint(options)), this._client);
     }
 
     /** Adds an HTTP endpoint */
     withHttpEndpoint(options?: WithHttpEndpointOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)), this._client);
     }
 
     /** Adds an HTTPS endpoint */
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)), this._client);
     }
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -21080,152 +21293,152 @@ class ProjectResourcePromiseImpl implements ProjectResourcePromise {
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.asHttp2Service()));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.asHttp2Service()), this._client);
     }
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)), this._client);
     }
 
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)), this._client);
     }
 
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)), this._client);
     }
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)), this._client);
     }
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)), this._client);
     }
 
     /** Configures the resource to copy container files from the specified source during publishing */
-    publishWithContainerFiles(source: ResourceWithContainerFiles, destinationPath: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.publishWithContainerFiles(source, destinationPath)));
+    publishWithContainerFiles(source: Awaitable<ResourceWithContainerFiles>, destinationPath: string): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.publishWithContainerFiles(source, destinationPath)), this._client);
     }
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()), this._client);
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)), this._client);
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)), this._client);
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()), this._client);
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)));
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)), this._client);
     }
 
     /** Adds a health check by key */
     withHealthCheck(key: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)), this._client);
     }
 
     /** Adds an HTTP health check */
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)), this._client);
     }
 
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)), this._client);
     }
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)), this._client);
     }
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)), this._client);
     }
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)), this._client);
     }
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()), this._client);
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)), this._client);
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)), this._client);
     }
 
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)), this._client);
     }
 
     /** Adds an HTTP health probe to the resource */
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)), this._client);
     }
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()), this._client);
     }
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)), this._client);
     }
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)), this._client);
     }
 
     /** Adds a pipeline step to the resource */
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)), this._client);
     }
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)), this._client);
     }
 
     /** Gets the resource name */
@@ -21235,147 +21448,147 @@ class ProjectResourcePromiseImpl implements ProjectResourcePromise {
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)), this._client);
     }
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)), this._client);
     }
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)), this._client);
     }
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)), this._client);
     }
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)), this._client);
     }
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ProjectResourcePromise {
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)), this._client);
     }
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ProjectResourcePromise {
-        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new ProjectResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -21386,7 +21599,7 @@ class ProjectResourcePromiseImpl implements ProjectResourcePromise {
 
 export interface TestDatabaseResource {
     toJSON(): MarshalledHandle;
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise;
     withBindMount(source: string, target: string, options?: WithBindMountOptions): TestDatabaseResourcePromise;
     withEntrypoint(entrypoint: string): TestDatabaseResourcePromise;
     withImageTag(tag: string): TestDatabaseResourcePromise;
@@ -21399,8 +21612,8 @@ export interface TestDatabaseResource {
     publishAsContainer(): TestDatabaseResourcePromise;
     withDockerfile(contextPath: string, options?: WithDockerfileOptions): TestDatabaseResourcePromise;
     withContainerName(name: string): TestDatabaseResourcePromise;
-    withBuildArg(name: string, value: ParameterResource): TestDatabaseResourcePromise;
-    withBuildSecret(name: string, value: ParameterResource): TestDatabaseResourcePromise;
+    withBuildArg(name: string, value: Awaitable<ParameterResource>): TestDatabaseResourcePromise;
+    withBuildSecret(name: string, value: Awaitable<ParameterResource>): TestDatabaseResourcePromise;
     withEndpointProxySupport(proxyEnabled: boolean): TestDatabaseResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): TestDatabaseResourcePromise;
     withContainerNetworkAlias(alias: string): TestDatabaseResourcePromise;
@@ -21409,18 +21622,18 @@ export interface TestDatabaseResource {
     withOtlpExporterProtocol(protocol: OtlpProtocol): TestDatabaseResourcePromise;
     publishAsConnectionString(): TestDatabaseResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): TestDatabaseResourcePromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): TestDatabaseResourcePromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): TestDatabaseResourcePromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): TestDatabaseResourcePromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): TestDatabaseResourcePromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): TestDatabaseResourcePromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): TestDatabaseResourcePromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): TestDatabaseResourcePromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): TestDatabaseResourcePromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise;
     withArgs(args: string[]): TestDatabaseResourcePromise;
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): TestDatabaseResourcePromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): TestDatabaseResourcePromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): TestDatabaseResourcePromise;
     withReferenceUri(name: string, uri: string): TestDatabaseResourcePromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): TestDatabaseResourcePromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): TestDatabaseResourcePromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): TestDatabaseResourcePromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): TestDatabaseResourcePromise;
     withEndpoint(options?: WithEndpointOptions): TestDatabaseResourcePromise;
     withHttpEndpoint(options?: WithHttpEndpointOptions): TestDatabaseResourcePromise;
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): TestDatabaseResourcePromise;
@@ -21433,12 +21646,12 @@ export interface TestDatabaseResource {
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): TestDatabaseResourcePromise;
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): TestDatabaseResourcePromise;
     excludeFromManifest(): TestDatabaseResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestDatabaseResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestDatabaseResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestDatabaseResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestDatabaseResourcePromise;
     withExplicitStart(): TestDatabaseResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): TestDatabaseResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): TestDatabaseResourcePromise;
     withHealthCheck(key: string): TestDatabaseResourcePromise;
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): TestDatabaseResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): TestDatabaseResourcePromise;
@@ -21446,8 +21659,8 @@ export interface TestDatabaseResource {
     withCertificateTrustScope(scope: CertificateTrustScope): TestDatabaseResourcePromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): TestDatabaseResourcePromise;
     withoutHttpsCertificate(): TestDatabaseResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): TestDatabaseResourcePromise;
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): TestDatabaseResourcePromise;
     excludeFromMcp(): TestDatabaseResourcePromise;
@@ -21472,9 +21685,9 @@ export interface TestDatabaseResource {
     withStatus(status: TestResourceStatus): TestDatabaseResourcePromise;
     withNestedConfig(config: TestNestedDto): TestDatabaseResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestDatabaseResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise;
     withEndpoints(endpoints: string[]): TestDatabaseResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): TestDatabaseResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestDatabaseResourcePromise;
@@ -21489,7 +21702,7 @@ export interface TestDatabaseResource {
 }
 
 export interface TestDatabaseResourcePromise extends PromiseLike<TestDatabaseResource> {
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise;
     withBindMount(source: string, target: string, options?: WithBindMountOptions): TestDatabaseResourcePromise;
     withEntrypoint(entrypoint: string): TestDatabaseResourcePromise;
     withImageTag(tag: string): TestDatabaseResourcePromise;
@@ -21502,8 +21715,8 @@ export interface TestDatabaseResourcePromise extends PromiseLike<TestDatabaseRes
     publishAsContainer(): TestDatabaseResourcePromise;
     withDockerfile(contextPath: string, options?: WithDockerfileOptions): TestDatabaseResourcePromise;
     withContainerName(name: string): TestDatabaseResourcePromise;
-    withBuildArg(name: string, value: ParameterResource): TestDatabaseResourcePromise;
-    withBuildSecret(name: string, value: ParameterResource): TestDatabaseResourcePromise;
+    withBuildArg(name: string, value: Awaitable<ParameterResource>): TestDatabaseResourcePromise;
+    withBuildSecret(name: string, value: Awaitable<ParameterResource>): TestDatabaseResourcePromise;
     withEndpointProxySupport(proxyEnabled: boolean): TestDatabaseResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): TestDatabaseResourcePromise;
     withContainerNetworkAlias(alias: string): TestDatabaseResourcePromise;
@@ -21512,18 +21725,18 @@ export interface TestDatabaseResourcePromise extends PromiseLike<TestDatabaseRes
     withOtlpExporterProtocol(protocol: OtlpProtocol): TestDatabaseResourcePromise;
     publishAsConnectionString(): TestDatabaseResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): TestDatabaseResourcePromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): TestDatabaseResourcePromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): TestDatabaseResourcePromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): TestDatabaseResourcePromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): TestDatabaseResourcePromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): TestDatabaseResourcePromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): TestDatabaseResourcePromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): TestDatabaseResourcePromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): TestDatabaseResourcePromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise;
     withArgs(args: string[]): TestDatabaseResourcePromise;
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): TestDatabaseResourcePromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): TestDatabaseResourcePromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): TestDatabaseResourcePromise;
     withReferenceUri(name: string, uri: string): TestDatabaseResourcePromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): TestDatabaseResourcePromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): TestDatabaseResourcePromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): TestDatabaseResourcePromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): TestDatabaseResourcePromise;
     withEndpoint(options?: WithEndpointOptions): TestDatabaseResourcePromise;
     withHttpEndpoint(options?: WithHttpEndpointOptions): TestDatabaseResourcePromise;
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): TestDatabaseResourcePromise;
@@ -21536,12 +21749,12 @@ export interface TestDatabaseResourcePromise extends PromiseLike<TestDatabaseRes
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): TestDatabaseResourcePromise;
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): TestDatabaseResourcePromise;
     excludeFromManifest(): TestDatabaseResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestDatabaseResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestDatabaseResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestDatabaseResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestDatabaseResourcePromise;
     withExplicitStart(): TestDatabaseResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): TestDatabaseResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): TestDatabaseResourcePromise;
     withHealthCheck(key: string): TestDatabaseResourcePromise;
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): TestDatabaseResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): TestDatabaseResourcePromise;
@@ -21549,8 +21762,8 @@ export interface TestDatabaseResourcePromise extends PromiseLike<TestDatabaseRes
     withCertificateTrustScope(scope: CertificateTrustScope): TestDatabaseResourcePromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): TestDatabaseResourcePromise;
     withoutHttpsCertificate(): TestDatabaseResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): TestDatabaseResourcePromise;
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): TestDatabaseResourcePromise;
     excludeFromMcp(): TestDatabaseResourcePromise;
@@ -21575,9 +21788,9 @@ export interface TestDatabaseResourcePromise extends PromiseLike<TestDatabaseRes
     withStatus(status: TestResourceStatus): TestDatabaseResourcePromise;
     withNestedConfig(config: TestNestedDto): TestDatabaseResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestDatabaseResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise;
     withEndpoints(endpoints: string[]): TestDatabaseResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): TestDatabaseResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestDatabaseResourcePromise;
@@ -21601,7 +21814,8 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** @internal */
-    private async _withContainerRegistryInternal(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestDatabaseResource> {
+    private async _withContainerRegistryInternal(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestDatabaseResource> {
+        registry = isPromiseLike(registry) ? await registry : registry;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, registry };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting/withContainerRegistry',
@@ -21611,8 +21825,8 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withContainerRegistryInternal(registry));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._withContainerRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -21629,7 +21843,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     /** Adds a bind mount */
     withBindMount(source: string, target: string, options?: WithBindMountOptions): TestDatabaseResourcePromise {
         const isReadOnly = options?.isReadOnly;
-        return new TestDatabaseResourcePromiseImpl(this._withBindMountInternal(source, target, isReadOnly));
+        return new TestDatabaseResourcePromiseImpl(this._withBindMountInternal(source, target, isReadOnly), this._client);
     }
 
     /** @internal */
@@ -21644,7 +21858,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the container entrypoint */
     withEntrypoint(entrypoint: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withEntrypointInternal(entrypoint));
+        return new TestDatabaseResourcePromiseImpl(this._withEntrypointInternal(entrypoint), this._client);
     }
 
     /** @internal */
@@ -21659,7 +21873,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the container image tag */
     withImageTag(tag: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withImageTagInternal(tag));
+        return new TestDatabaseResourcePromiseImpl(this._withImageTagInternal(tag), this._client);
     }
 
     /** @internal */
@@ -21674,7 +21888,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the container image registry */
     withImageRegistry(registry: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withImageRegistryInternal(registry));
+        return new TestDatabaseResourcePromiseImpl(this._withImageRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -21691,7 +21905,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     /** Sets the container image */
     withImage(image: string, options?: WithImageOptions): TestDatabaseResourcePromise {
         const tag = options?.tag;
-        return new TestDatabaseResourcePromiseImpl(this._withImageInternal(image, tag));
+        return new TestDatabaseResourcePromiseImpl(this._withImageInternal(image, tag), this._client);
     }
 
     /** @internal */
@@ -21706,7 +21920,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the image SHA256 digest */
     withImageSHA256(sha256: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withImageSHA256Internal(sha256));
+        return new TestDatabaseResourcePromiseImpl(this._withImageSHA256Internal(sha256), this._client);
     }
 
     /** @internal */
@@ -21721,7 +21935,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Adds runtime arguments for the container */
     withContainerRuntimeArgs(args: string[]): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withContainerRuntimeArgsInternal(args));
+        return new TestDatabaseResourcePromiseImpl(this._withContainerRuntimeArgsInternal(args), this._client);
     }
 
     /** @internal */
@@ -21736,7 +21950,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the lifetime behavior of the container resource */
     withLifetime(lifetime: ContainerLifetime): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withLifetimeInternal(lifetime));
+        return new TestDatabaseResourcePromiseImpl(this._withLifetimeInternal(lifetime), this._client);
     }
 
     /** @internal */
@@ -21751,7 +21965,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the container image pull policy */
     withImagePullPolicy(pullPolicy: ImagePullPolicy): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withImagePullPolicyInternal(pullPolicy));
+        return new TestDatabaseResourcePromiseImpl(this._withImagePullPolicyInternal(pullPolicy), this._client);
     }
 
     /** @internal */
@@ -21766,7 +21980,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures the resource to be published as a container */
     publishAsContainer(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._publishAsContainerInternal());
+        return new TestDatabaseResourcePromiseImpl(this._publishAsContainerInternal(), this._client);
     }
 
     /** @internal */
@@ -21785,7 +21999,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     withDockerfile(contextPath: string, options?: WithDockerfileOptions): TestDatabaseResourcePromise {
         const dockerfilePath = options?.dockerfilePath;
         const stage = options?.stage;
-        return new TestDatabaseResourcePromiseImpl(this._withDockerfileInternal(contextPath, dockerfilePath, stage));
+        return new TestDatabaseResourcePromiseImpl(this._withDockerfileInternal(contextPath, dockerfilePath, stage), this._client);
     }
 
     /** @internal */
@@ -21800,11 +22014,12 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the container name */
     withContainerName(name: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withContainerNameInternal(name));
+        return new TestDatabaseResourcePromiseImpl(this._withContainerNameInternal(name), this._client);
     }
 
     /** @internal */
-    private async _withBuildArgInternal(name: string, value: ParameterResource): Promise<TestDatabaseResource> {
+    private async _withBuildArgInternal(name: string, value: Awaitable<ParameterResource>): Promise<TestDatabaseResource> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting/withParameterBuildArg',
@@ -21814,12 +22029,13 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Adds a build argument from a parameter resource */
-    withBuildArg(name: string, value: ParameterResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withBuildArgInternal(name, value));
+    withBuildArg(name: string, value: Awaitable<ParameterResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._withBuildArgInternal(name, value), this._client);
     }
 
     /** @internal */
-    private async _withBuildSecretInternal(name: string, value: ParameterResource): Promise<TestDatabaseResource> {
+    private async _withBuildSecretInternal(name: string, value: Awaitable<ParameterResource>): Promise<TestDatabaseResource> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting/withParameterBuildSecret',
@@ -21829,8 +22045,8 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Adds a build secret from a parameter resource */
-    withBuildSecret(name: string, value: ParameterResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withBuildSecretInternal(name, value));
+    withBuildSecret(name: string, value: Awaitable<ParameterResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._withBuildSecretInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -21845,7 +22061,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures endpoint proxy support */
     withEndpointProxySupport(proxyEnabled: boolean): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withEndpointProxySupportInternal(proxyEnabled));
+        return new TestDatabaseResourcePromiseImpl(this._withEndpointProxySupportInternal(proxyEnabled), this._client);
     }
 
     /** @internal */
@@ -21864,7 +22080,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): TestDatabaseResourcePromise {
         const buildImage = options?.buildImage;
         const runtimeImage = options?.runtimeImage;
-        return new TestDatabaseResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage));
+        return new TestDatabaseResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage), this._client);
     }
 
     /** @internal */
@@ -21879,7 +22095,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Adds a network alias for the container */
     withContainerNetworkAlias(alias: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withContainerNetworkAliasInternal(alias));
+        return new TestDatabaseResourcePromiseImpl(this._withContainerNetworkAliasInternal(alias), this._client);
     }
 
     /** @internal */
@@ -21898,7 +22114,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     withMcpServer(options?: WithMcpServerOptions): TestDatabaseResourcePromise {
         const path = options?.path;
         const endpointName = options?.endpointName;
-        return new TestDatabaseResourcePromiseImpl(this._withMcpServerInternal(path, endpointName));
+        return new TestDatabaseResourcePromiseImpl(this._withMcpServerInternal(path, endpointName), this._client);
     }
 
     /** @internal */
@@ -21913,7 +22129,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withOtlpExporterInternal());
+        return new TestDatabaseResourcePromiseImpl(this._withOtlpExporterInternal(), this._client);
     }
 
     /** @internal */
@@ -21928,7 +22144,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withOtlpExporterProtocolInternal(protocol));
+        return new TestDatabaseResourcePromiseImpl(this._withOtlpExporterProtocolInternal(protocol), this._client);
     }
 
     /** @internal */
@@ -21943,7 +22159,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Publishes the resource as a connection string */
     publishAsConnectionString(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._publishAsConnectionStringInternal());
+        return new TestDatabaseResourcePromiseImpl(this._publishAsConnectionStringInternal(), this._client);
     }
 
     /** @internal */
@@ -21960,11 +22176,12 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): TestDatabaseResourcePromise {
         const helpLink = options?.helpLink;
-        return new TestDatabaseResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink));
+        return new TestDatabaseResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): Promise<TestDatabaseResource> {
+    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): Promise<TestDatabaseResource> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting/withEnvironment',
@@ -21974,8 +22191,8 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withEnvironmentInternal(name, value));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._withEnvironmentInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -21993,7 +22210,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withEnvironmentExpressionInternal(name, value));
+        return new TestDatabaseResourcePromiseImpl(this._withEnvironmentExpressionInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -22013,11 +22230,12 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withEnvironmentCallbackInternal(callback));
+        return new TestDatabaseResourcePromiseImpl(this._withEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentEndpointInternal(name: string, endpointReference: EndpointReference): Promise<TestDatabaseResource> {
+    private async _withEnvironmentEndpointInternal(name: string, endpointReference: Awaitable<EndpointReference>): Promise<TestDatabaseResource> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, endpointReference };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting/withEnvironmentEndpoint',
@@ -22030,12 +22248,13 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentParameterInternal(name: string, parameter: ParameterResource): Promise<TestDatabaseResource> {
+    private async _withEnvironmentParameterInternal(name: string, parameter: Awaitable<ParameterResource>): Promise<TestDatabaseResource> {
+        parameter = isPromiseLike(parameter) ? await parameter : parameter;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, parameter };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting/withEnvironmentParameter',
@@ -22048,12 +22267,13 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withEnvironmentParameterInternal(name, parameter));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._withEnvironmentParameterInternal(name, parameter), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<TestDatabaseResource> {
+    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<TestDatabaseResource> {
+        resource = isPromiseLike(resource) ? await resource : resource;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, envVarName, resource };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting/withEnvironmentConnectionString',
@@ -22066,8 +22286,8 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource), this._client);
     }
 
     /** @internal */
@@ -22082,7 +22302,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Adds arguments */
     withArgs(args: string[]): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withArgsInternal(args));
+        return new TestDatabaseResourcePromiseImpl(this._withArgsInternal(args), this._client);
     }
 
     /** @internal */
@@ -22102,11 +22322,12 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withArgsCallbackInternal(callback));
+        return new TestDatabaseResourcePromiseImpl(this._withArgsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withReferenceInternal(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, connectionName?: string, optional?: boolean, name?: string): Promise<TestDatabaseResource> {
+    private async _withReferenceInternal(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, connectionName?: string, optional?: boolean, name?: string): Promise<TestDatabaseResource> {
+        source = isPromiseLike(source) ? await source : source;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, source };
         if (connectionName !== undefined) rpcArgs.connectionName = connectionName;
         if (optional !== undefined) rpcArgs.optional = optional;
@@ -22119,11 +22340,11 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): TestDatabaseResourcePromise {
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): TestDatabaseResourcePromise {
         const connectionName = options?.connectionName;
         const optional = options?.optional;
         const name = options?.name;
-        return new TestDatabaseResourcePromiseImpl(this._withReferenceInternal(source, connectionName, optional, name));
+        return new TestDatabaseResourcePromiseImpl(this._withReferenceInternal(source, connectionName, optional, name), this._client);
     }
 
     /** @internal */
@@ -22138,11 +22359,12 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withReferenceUriInternal(name, uri));
+        return new TestDatabaseResourcePromiseImpl(this._withReferenceUriInternal(name, uri), this._client);
     }
 
     /** @internal */
-    private async _withReferenceExternalServiceInternal(externalService: ExternalServiceResource): Promise<TestDatabaseResource> {
+    private async _withReferenceExternalServiceInternal(externalService: Awaitable<ExternalServiceResource>): Promise<TestDatabaseResource> {
+        externalService = isPromiseLike(externalService) ? await externalService : externalService;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, externalService };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting/withReferenceExternalService',
@@ -22152,12 +22374,13 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withReferenceExternalServiceInternal(externalService));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._withReferenceExternalServiceInternal(externalService), this._client);
     }
 
     /** @internal */
-    private async _withReferenceEndpointInternal(endpointReference: EndpointReference): Promise<TestDatabaseResource> {
+    private async _withReferenceEndpointInternal(endpointReference: Awaitable<EndpointReference>): Promise<TestDatabaseResource> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, endpointReference };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting/withReferenceEndpoint',
@@ -22167,8 +22390,8 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withReferenceEndpointInternal(endpointReference));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._withReferenceEndpointInternal(endpointReference), this._client);
     }
 
     /** @internal */
@@ -22199,7 +22422,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
         const isProxied = options?.isProxied;
         const isExternal = options?.isExternal;
         const protocol = options?.protocol;
-        return new TestDatabaseResourcePromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol));
+        return new TestDatabaseResourcePromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol), this._client);
     }
 
     /** @internal */
@@ -22224,7 +22447,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new TestDatabaseResourcePromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied));
+        return new TestDatabaseResourcePromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -22249,7 +22472,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new TestDatabaseResourcePromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied));
+        return new TestDatabaseResourcePromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -22264,7 +22487,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withExternalHttpEndpointsInternal());
+        return new TestDatabaseResourcePromiseImpl(this._withExternalHttpEndpointsInternal(), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -22288,7 +22511,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._asHttp2ServiceInternal());
+        return new TestDatabaseResourcePromiseImpl(this._asHttp2ServiceInternal(), this._client);
     }
 
     /** @internal */
@@ -22308,7 +22531,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withUrlsCallbackInternal(callback));
+        return new TestDatabaseResourcePromiseImpl(this._withUrlsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -22325,7 +22548,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): TestDatabaseResourcePromise {
         const displayText = options?.displayText;
-        return new TestDatabaseResourcePromiseImpl(this._withUrlInternal(url, displayText));
+        return new TestDatabaseResourcePromiseImpl(this._withUrlInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -22342,7 +22565,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): TestDatabaseResourcePromise {
         const displayText = options?.displayText;
-        return new TestDatabaseResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText));
+        return new TestDatabaseResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -22361,7 +22584,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback));
+        return new TestDatabaseResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -22381,7 +22604,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback));
+        return new TestDatabaseResourcePromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -22396,11 +22619,12 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._excludeFromManifestInternal());
+        return new TestDatabaseResourcePromiseImpl(this._excludeFromManifestInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestDatabaseResource> {
+    private async _waitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestDatabaseResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting/waitForResource',
@@ -22410,12 +22634,13 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._waitForInternal(dependency));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._waitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<TestDatabaseResource> {
+    private async _waitForWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<TestDatabaseResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting/waitForWithBehavior',
@@ -22425,12 +22650,13 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
-    private async _waitForStartInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestDatabaseResource> {
+    private async _waitForStartInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestDatabaseResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting/waitForResourceStart',
@@ -22440,12 +22666,13 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._waitForStartInternal(dependency));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._waitForStartInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForStartWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<TestDatabaseResource> {
+    private async _waitForStartWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<TestDatabaseResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting/waitForStartWithBehavior',
@@ -22455,8 +22682,8 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
@@ -22471,11 +22698,12 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withExplicitStartInternal());
+        return new TestDatabaseResourcePromiseImpl(this._withExplicitStartInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForCompletionInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, exitCode?: number): Promise<TestDatabaseResource> {
+    private async _waitForCompletionInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, exitCode?: number): Promise<TestDatabaseResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         if (exitCode !== undefined) rpcArgs.exitCode = exitCode;
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
@@ -22486,9 +22714,9 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): TestDatabaseResourcePromise {
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): TestDatabaseResourcePromise {
         const exitCode = options?.exitCode;
-        return new TestDatabaseResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode));
+        return new TestDatabaseResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode), this._client);
     }
 
     /** @internal */
@@ -22503,7 +22731,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Adds a health check by key */
     withHealthCheck(key: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withHealthCheckInternal(key));
+        return new TestDatabaseResourcePromiseImpl(this._withHealthCheckInternal(key), this._client);
     }
 
     /** @internal */
@@ -22524,7 +22752,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
         const path = options?.path;
         const statusCode = options?.statusCode;
         const endpointName = options?.endpointName;
-        return new TestDatabaseResourcePromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName));
+        return new TestDatabaseResourcePromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName), this._client);
     }
 
     /** @internal */
@@ -22546,7 +22774,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): TestDatabaseResourcePromise {
         const commandOptions = options?.commandOptions;
-        return new TestDatabaseResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions));
+        return new TestDatabaseResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions), this._client);
     }
 
     /** @internal */
@@ -22561,7 +22789,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withDeveloperCertificateTrustInternal(trust));
+        return new TestDatabaseResourcePromiseImpl(this._withDeveloperCertificateTrustInternal(trust), this._client);
     }
 
     /** @internal */
@@ -22576,11 +22804,12 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withCertificateTrustScopeInternal(scope));
+        return new TestDatabaseResourcePromiseImpl(this._withCertificateTrustScopeInternal(scope), this._client);
     }
 
     /** @internal */
-    private async _withHttpsDeveloperCertificateInternal(password?: ParameterResource): Promise<TestDatabaseResource> {
+    private async _withHttpsDeveloperCertificateInternal(password?: Awaitable<ParameterResource>): Promise<TestDatabaseResource> {
+        password = isPromiseLike(password) ? await password : password;
         const rpcArgs: Record<string, unknown> = { builder: this._handle };
         if (password !== undefined) rpcArgs.password = password;
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
@@ -22592,8 +22821,8 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): TestDatabaseResourcePromise {
-        const password = options?.password;
-        return new TestDatabaseResourcePromiseImpl(this._withHttpsDeveloperCertificateInternal(password));
+        let password = options?.password;
+        return new TestDatabaseResourcePromiseImpl(this._withHttpsDeveloperCertificateInternal(password), this._client);
     }
 
     /** @internal */
@@ -22608,11 +22837,12 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withoutHttpsCertificateInternal());
+        return new TestDatabaseResourcePromiseImpl(this._withoutHttpsCertificateInternal(), this._client);
     }
 
     /** @internal */
-    private async _withParentRelationshipInternal(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestDatabaseResource> {
+    private async _withParentRelationshipInternal(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestDatabaseResource> {
+        parent = isPromiseLike(parent) ? await parent : parent;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, parent };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting/withBuilderParentRelationship',
@@ -22622,12 +22852,13 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withParentRelationshipInternal(parent));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._withParentRelationshipInternal(parent), this._client);
     }
 
     /** @internal */
-    private async _withChildRelationshipInternal(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestDatabaseResource> {
+    private async _withChildRelationshipInternal(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestDatabaseResource> {
+        child = isPromiseLike(child) ? await child : child;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, child };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting/withBuilderChildRelationship',
@@ -22637,8 +22868,8 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withChildRelationshipInternal(child));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._withChildRelationshipInternal(child), this._client);
     }
 
     /** @internal */
@@ -22655,7 +22886,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): TestDatabaseResourcePromise {
         const iconVariant = options?.iconVariant;
-        return new TestDatabaseResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant));
+        return new TestDatabaseResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant), this._client);
     }
 
     /** @internal */
@@ -22684,7 +22915,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
         const failureThreshold = options?.failureThreshold;
         const successThreshold = options?.successThreshold;
         const endpointName = options?.endpointName;
-        return new TestDatabaseResourcePromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName));
+        return new TestDatabaseResourcePromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName), this._client);
     }
 
     /** @internal */
@@ -22699,7 +22930,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._excludeFromMcpInternal());
+        return new TestDatabaseResourcePromiseImpl(this._excludeFromMcpInternal(), this._client);
     }
 
     /** @internal */
@@ -22714,7 +22945,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName));
+        return new TestDatabaseResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName), this._client);
     }
 
     /** @internal */
@@ -22729,7 +22960,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag));
+        return new TestDatabaseResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag), this._client);
     }
 
     /** @internal */
@@ -22757,7 +22988,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
         const requiredBy = options?.requiredBy;
         const tags = options?.tags;
         const description = options?.description;
-        return new TestDatabaseResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description));
+        return new TestDatabaseResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description), this._client);
     }
 
     /** @internal */
@@ -22777,7 +23008,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withPipelineConfigurationInternal(callback));
+        return new TestDatabaseResourcePromiseImpl(this._withPipelineConfigurationInternal(callback), this._client);
     }
 
     /** @internal */
@@ -22796,7 +23027,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     withVolume(target: string, options?: WithVolumeOptions): TestDatabaseResourcePromise {
         const name = options?.name;
         const isReadOnly = options?.isReadOnly;
-        return new TestDatabaseResourcePromiseImpl(this._withVolumeInternal(target, name, isReadOnly));
+        return new TestDatabaseResourcePromiseImpl(this._withVolumeInternal(target, name, isReadOnly), this._client);
     }
 
     /** Gets the resource name */
@@ -22825,7 +23056,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback));
+        return new TestDatabaseResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -22845,7 +23076,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._onResourceStoppedInternal(callback));
+        return new TestDatabaseResourcePromiseImpl(this._onResourceStoppedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -22865,7 +23096,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._onInitializeResourceInternal(callback));
+        return new TestDatabaseResourcePromiseImpl(this._onInitializeResourceInternal(callback), this._client);
     }
 
     /** @internal */
@@ -22885,7 +23116,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._onResourceEndpointsAllocatedInternal(callback));
+        return new TestDatabaseResourcePromiseImpl(this._onResourceEndpointsAllocatedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -22905,7 +23136,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._onResourceReadyInternal(callback));
+        return new TestDatabaseResourcePromiseImpl(this._onResourceReadyInternal(callback), this._client);
     }
 
     /** @internal */
@@ -22924,7 +23155,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     withOptionalString(options?: WithOptionalStringOptions): TestDatabaseResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new TestDatabaseResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new TestDatabaseResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -22939,7 +23170,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withConfigInternal(config));
+        return new TestDatabaseResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -22959,7 +23190,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback));
+        return new TestDatabaseResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -22974,7 +23205,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new TestDatabaseResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -22989,7 +23220,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new TestDatabaseResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -23004,7 +23235,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new TestDatabaseResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -23026,7 +23257,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): TestDatabaseResourcePromise {
         const callback = options?.callback;
-        return new TestDatabaseResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new TestDatabaseResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -23041,7 +23272,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withStatusInternal(status));
+        return new TestDatabaseResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -23056,7 +23287,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new TestDatabaseResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -23076,11 +23307,12 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new TestDatabaseResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestDatabaseResource> {
+    private async _testWaitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestDatabaseResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -23090,12 +23322,13 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<TestDatabaseResource> {
+    private async _withDependencyInternal(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<TestDatabaseResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -23105,12 +23338,13 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<TestDatabaseResource> {
+    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<TestDatabaseResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestDatabaseResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -23120,8 +23354,8 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -23136,7 +23370,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new TestDatabaseResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -23151,7 +23385,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables));
+        return new TestDatabaseResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables), this._client);
     }
 
     /** @internal */
@@ -23170,7 +23404,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new TestDatabaseResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** @internal */
@@ -23185,7 +23419,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new TestDatabaseResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -23200,7 +23434,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new TestDatabaseResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -23215,7 +23449,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new TestDatabaseResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -23230,7 +23464,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new TestDatabaseResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -23249,7 +23483,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): TestDatabaseResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new TestDatabaseResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new TestDatabaseResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -23268,7 +23502,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): TestDatabaseResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new TestDatabaseResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new TestDatabaseResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -23283,7 +23517,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new TestDatabaseResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -23298,7 +23532,7 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new TestDatabaseResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -23309,7 +23543,9 @@ class TestDatabaseResourceImpl extends ResourceBuilderBase<TestDatabaseResourceH
  * await builder.addSomething().withX().withY();
  */
 class TestDatabaseResourcePromiseImpl implements TestDatabaseResourcePromise {
-    constructor(private _promise: Promise<TestDatabaseResource>) {}
+    constructor(private _promise: Promise<TestDatabaseResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = TestDatabaseResource, TResult2 = never>(
         onfulfilled?: ((value: TestDatabaseResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -23319,123 +23555,123 @@ class TestDatabaseResourcePromiseImpl implements TestDatabaseResourcePromise {
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)), this._client);
     }
 
     /** Adds a bind mount */
     withBindMount(source: string, target: string, options?: WithBindMountOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withBindMount(source, target, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withBindMount(source, target, options)), this._client);
     }
 
     /** Sets the container entrypoint */
     withEntrypoint(entrypoint: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEntrypoint(entrypoint)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEntrypoint(entrypoint)), this._client);
     }
 
     /** Sets the container image tag */
     withImageTag(tag: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withImageTag(tag)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withImageTag(tag)), this._client);
     }
 
     /** Sets the container image registry */
     withImageRegistry(registry: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withImageRegistry(registry)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withImageRegistry(registry)), this._client);
     }
 
     /** Sets the container image */
     withImage(image: string, options?: WithImageOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withImage(image, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withImage(image, options)), this._client);
     }
 
     /** Sets the image SHA256 digest */
     withImageSHA256(sha256: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withImageSHA256(sha256)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withImageSHA256(sha256)), this._client);
     }
 
     /** Adds runtime arguments for the container */
     withContainerRuntimeArgs(args: string[]): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withContainerRuntimeArgs(args)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withContainerRuntimeArgs(args)), this._client);
     }
 
     /** Sets the lifetime behavior of the container resource */
     withLifetime(lifetime: ContainerLifetime): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withLifetime(lifetime)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withLifetime(lifetime)), this._client);
     }
 
     /** Sets the container image pull policy */
     withImagePullPolicy(pullPolicy: ImagePullPolicy): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withImagePullPolicy(pullPolicy)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withImagePullPolicy(pullPolicy)), this._client);
     }
 
     /** Configures the resource to be published as a container */
     publishAsContainer(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.publishAsContainer()));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.publishAsContainer()), this._client);
     }
 
     /** Configures the resource to use a Dockerfile */
     withDockerfile(contextPath: string, options?: WithDockerfileOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withDockerfile(contextPath, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withDockerfile(contextPath, options)), this._client);
     }
 
     /** Sets the container name */
     withContainerName(name: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withContainerName(name)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withContainerName(name)), this._client);
     }
 
     /** Adds a build argument from a parameter resource */
-    withBuildArg(name: string, value: ParameterResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withBuildArg(name, value)));
+    withBuildArg(name: string, value: Awaitable<ParameterResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withBuildArg(name, value)), this._client);
     }
 
     /** Adds a build secret from a parameter resource */
-    withBuildSecret(name: string, value: ParameterResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withBuildSecret(name, value)));
+    withBuildSecret(name: string, value: Awaitable<ParameterResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withBuildSecret(name, value)), this._client);
     }
 
     /** Configures endpoint proxy support */
     withEndpointProxySupport(proxyEnabled: boolean): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEndpointProxySupport(proxyEnabled)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEndpointProxySupport(proxyEnabled)), this._client);
     }
 
     /** Sets the base image for a Dockerfile build */
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)), this._client);
     }
 
     /** Adds a network alias for the container */
     withContainerNetworkAlias(alias: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withContainerNetworkAlias(alias)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withContainerNetworkAlias(alias)), this._client);
     }
 
     /** Configures an MCP server endpoint on the resource */
     withMcpServer(options?: WithMcpServerOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMcpServer(options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMcpServer(options)), this._client);
     }
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporter()));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporter()), this._client);
     }
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)), this._client);
     }
 
     /** Publishes the resource as a connection string */
     publishAsConnectionString(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.publishAsConnectionString()));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.publishAsConnectionString()), this._client);
     }
 
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)), this._client);
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)), this._client);
     }
 
     /**
@@ -23443,86 +23679,86 @@ class TestDatabaseResourcePromiseImpl implements TestDatabaseResourcePromise {
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)), this._client);
     }
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)), this._client);
     }
 
     /**
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)), this._client);
     }
 
     /**
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)), this._client);
     }
 
     /**
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)), this._client);
     }
 
     /** Adds arguments */
     withArgs(args: string[]): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withArgs(args)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withArgs(args)), this._client);
     }
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)), this._client);
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withReference(source, options)));
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withReference(source, options)), this._client);
     }
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)), this._client);
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)), this._client);
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)), this._client);
     }
 
     /** Adds a network endpoint */
     withEndpoint(options?: WithEndpointOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEndpoint(options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEndpoint(options)), this._client);
     }
 
     /** Adds an HTTP endpoint */
     withHttpEndpoint(options?: WithHttpEndpointOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)), this._client);
     }
 
     /** Adds an HTTPS endpoint */
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)), this._client);
     }
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -23532,152 +23768,152 @@ class TestDatabaseResourcePromiseImpl implements TestDatabaseResourcePromise {
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.asHttp2Service()));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.asHttp2Service()), this._client);
     }
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)), this._client);
     }
 
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)), this._client);
     }
 
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)), this._client);
     }
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)), this._client);
     }
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)), this._client);
     }
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()), this._client);
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)), this._client);
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)), this._client);
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()), this._client);
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)));
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)), this._client);
     }
 
     /** Adds a health check by key */
     withHealthCheck(key: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)), this._client);
     }
 
     /** Adds an HTTP health check */
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)), this._client);
     }
 
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)), this._client);
     }
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)), this._client);
     }
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)), this._client);
     }
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)), this._client);
     }
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()), this._client);
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)), this._client);
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)), this._client);
     }
 
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)), this._client);
     }
 
     /** Adds an HTTP health probe to the resource */
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)), this._client);
     }
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()), this._client);
     }
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)), this._client);
     }
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)), this._client);
     }
 
     /** Adds a pipeline step to the resource */
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)), this._client);
     }
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)), this._client);
     }
 
     /** Adds a volume */
     withVolume(target: string, options?: WithVolumeOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withVolume(target, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withVolume(target, options)), this._client);
     }
 
     /** Gets the resource name */
@@ -23687,147 +23923,147 @@ class TestDatabaseResourcePromiseImpl implements TestDatabaseResourcePromise {
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)), this._client);
     }
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)), this._client);
     }
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)), this._client);
     }
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)), this._client);
     }
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)), this._client);
     }
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestDatabaseResourcePromise {
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)), this._client);
     }
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -23838,7 +24074,7 @@ class TestDatabaseResourcePromiseImpl implements TestDatabaseResourcePromise {
 
 export interface TestRedisResource {
     toJSON(): MarshalledHandle;
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise;
     withBindMount(source: string, target: string, options?: WithBindMountOptions): TestRedisResourcePromise;
     withEntrypoint(entrypoint: string): TestRedisResourcePromise;
     withImageTag(tag: string): TestRedisResourcePromise;
@@ -23851,8 +24087,8 @@ export interface TestRedisResource {
     publishAsContainer(): TestRedisResourcePromise;
     withDockerfile(contextPath: string, options?: WithDockerfileOptions): TestRedisResourcePromise;
     withContainerName(name: string): TestRedisResourcePromise;
-    withBuildArg(name: string, value: ParameterResource): TestRedisResourcePromise;
-    withBuildSecret(name: string, value: ParameterResource): TestRedisResourcePromise;
+    withBuildArg(name: string, value: Awaitable<ParameterResource>): TestRedisResourcePromise;
+    withBuildSecret(name: string, value: Awaitable<ParameterResource>): TestRedisResourcePromise;
     withEndpointProxySupport(proxyEnabled: boolean): TestRedisResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): TestRedisResourcePromise;
     withContainerNetworkAlias(alias: string): TestRedisResourcePromise;
@@ -23861,21 +24097,21 @@ export interface TestRedisResource {
     withOtlpExporterProtocol(protocol: OtlpProtocol): TestRedisResourcePromise;
     publishAsConnectionString(): TestRedisResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): TestRedisResourcePromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): TestRedisResourcePromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): TestRedisResourcePromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): TestRedisResourcePromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): TestRedisResourcePromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): TestRedisResourcePromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): TestRedisResourcePromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): TestRedisResourcePromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): TestRedisResourcePromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise;
     withConnectionProperty(name: string, value: ReferenceExpression): TestRedisResourcePromise;
     withConnectionPropertyValue(name: string, value: string): TestRedisResourcePromise;
     withArgs(args: string[]): TestRedisResourcePromise;
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): TestRedisResourcePromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): TestRedisResourcePromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): TestRedisResourcePromise;
     getConnectionProperty(key: string): Promise<ReferenceExpression>;
     withReferenceUri(name: string, uri: string): TestRedisResourcePromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): TestRedisResourcePromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): TestRedisResourcePromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): TestRedisResourcePromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): TestRedisResourcePromise;
     withEndpoint(options?: WithEndpointOptions): TestRedisResourcePromise;
     withHttpEndpoint(options?: WithHttpEndpointOptions): TestRedisResourcePromise;
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): TestRedisResourcePromise;
@@ -23888,12 +24124,12 @@ export interface TestRedisResource {
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): TestRedisResourcePromise;
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): TestRedisResourcePromise;
     excludeFromManifest(): TestRedisResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestRedisResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestRedisResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestRedisResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestRedisResourcePromise;
     withExplicitStart(): TestRedisResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): TestRedisResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): TestRedisResourcePromise;
     withHealthCheck(key: string): TestRedisResourcePromise;
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): TestRedisResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): TestRedisResourcePromise;
@@ -23901,8 +24137,8 @@ export interface TestRedisResource {
     withCertificateTrustScope(scope: CertificateTrustScope): TestRedisResourcePromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): TestRedisResourcePromise;
     withoutHttpsCertificate(): TestRedisResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): TestRedisResourcePromise;
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): TestRedisResourcePromise;
     excludeFromMcp(): TestRedisResourcePromise;
@@ -23933,12 +24169,12 @@ export interface TestRedisResource {
     withStatus(status: TestResourceStatus): TestRedisResourcePromise;
     withNestedConfig(config: TestNestedDto): TestRedisResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestRedisResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise;
     getEndpoints(): Promise<string[]>;
     withConnectionStringDirect(connectionString: string): TestRedisResourcePromise;
     withRedisSpecific(option: string): TestRedisResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise;
     withEndpoints(endpoints: string[]): TestRedisResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): TestRedisResourcePromise;
     getStatusAsync(options?: GetStatusAsyncOptions): Promise<string>;
@@ -23957,7 +24193,7 @@ export interface TestRedisResource {
 }
 
 export interface TestRedisResourcePromise extends PromiseLike<TestRedisResource> {
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise;
     withBindMount(source: string, target: string, options?: WithBindMountOptions): TestRedisResourcePromise;
     withEntrypoint(entrypoint: string): TestRedisResourcePromise;
     withImageTag(tag: string): TestRedisResourcePromise;
@@ -23970,8 +24206,8 @@ export interface TestRedisResourcePromise extends PromiseLike<TestRedisResource>
     publishAsContainer(): TestRedisResourcePromise;
     withDockerfile(contextPath: string, options?: WithDockerfileOptions): TestRedisResourcePromise;
     withContainerName(name: string): TestRedisResourcePromise;
-    withBuildArg(name: string, value: ParameterResource): TestRedisResourcePromise;
-    withBuildSecret(name: string, value: ParameterResource): TestRedisResourcePromise;
+    withBuildArg(name: string, value: Awaitable<ParameterResource>): TestRedisResourcePromise;
+    withBuildSecret(name: string, value: Awaitable<ParameterResource>): TestRedisResourcePromise;
     withEndpointProxySupport(proxyEnabled: boolean): TestRedisResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): TestRedisResourcePromise;
     withContainerNetworkAlias(alias: string): TestRedisResourcePromise;
@@ -23980,21 +24216,21 @@ export interface TestRedisResourcePromise extends PromiseLike<TestRedisResource>
     withOtlpExporterProtocol(protocol: OtlpProtocol): TestRedisResourcePromise;
     publishAsConnectionString(): TestRedisResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): TestRedisResourcePromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): TestRedisResourcePromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): TestRedisResourcePromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): TestRedisResourcePromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): TestRedisResourcePromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): TestRedisResourcePromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): TestRedisResourcePromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): TestRedisResourcePromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): TestRedisResourcePromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise;
     withConnectionProperty(name: string, value: ReferenceExpression): TestRedisResourcePromise;
     withConnectionPropertyValue(name: string, value: string): TestRedisResourcePromise;
     withArgs(args: string[]): TestRedisResourcePromise;
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): TestRedisResourcePromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): TestRedisResourcePromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): TestRedisResourcePromise;
     getConnectionProperty(key: string): Promise<ReferenceExpression>;
     withReferenceUri(name: string, uri: string): TestRedisResourcePromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): TestRedisResourcePromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): TestRedisResourcePromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): TestRedisResourcePromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): TestRedisResourcePromise;
     withEndpoint(options?: WithEndpointOptions): TestRedisResourcePromise;
     withHttpEndpoint(options?: WithHttpEndpointOptions): TestRedisResourcePromise;
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): TestRedisResourcePromise;
@@ -24007,12 +24243,12 @@ export interface TestRedisResourcePromise extends PromiseLike<TestRedisResource>
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): TestRedisResourcePromise;
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): TestRedisResourcePromise;
     excludeFromManifest(): TestRedisResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestRedisResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestRedisResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestRedisResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestRedisResourcePromise;
     withExplicitStart(): TestRedisResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): TestRedisResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): TestRedisResourcePromise;
     withHealthCheck(key: string): TestRedisResourcePromise;
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): TestRedisResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): TestRedisResourcePromise;
@@ -24020,8 +24256,8 @@ export interface TestRedisResourcePromise extends PromiseLike<TestRedisResource>
     withCertificateTrustScope(scope: CertificateTrustScope): TestRedisResourcePromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): TestRedisResourcePromise;
     withoutHttpsCertificate(): TestRedisResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): TestRedisResourcePromise;
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): TestRedisResourcePromise;
     excludeFromMcp(): TestRedisResourcePromise;
@@ -24052,12 +24288,12 @@ export interface TestRedisResourcePromise extends PromiseLike<TestRedisResource>
     withStatus(status: TestResourceStatus): TestRedisResourcePromise;
     withNestedConfig(config: TestNestedDto): TestRedisResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestRedisResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise;
     getEndpoints(): Promise<string[]>;
     withConnectionStringDirect(connectionString: string): TestRedisResourcePromise;
     withRedisSpecific(option: string): TestRedisResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise;
     withEndpoints(endpoints: string[]): TestRedisResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): TestRedisResourcePromise;
     getStatusAsync(options?: GetStatusAsyncOptions): Promise<string>;
@@ -24085,7 +24321,8 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** @internal */
-    private async _withContainerRegistryInternal(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestRedisResource> {
+    private async _withContainerRegistryInternal(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestRedisResource> {
+        registry = isPromiseLike(registry) ? await registry : registry;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, registry };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting/withContainerRegistry',
@@ -24095,8 +24332,8 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withContainerRegistryInternal(registry));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._withContainerRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -24113,7 +24350,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     /** Adds a bind mount */
     withBindMount(source: string, target: string, options?: WithBindMountOptions): TestRedisResourcePromise {
         const isReadOnly = options?.isReadOnly;
-        return new TestRedisResourcePromiseImpl(this._withBindMountInternal(source, target, isReadOnly));
+        return new TestRedisResourcePromiseImpl(this._withBindMountInternal(source, target, isReadOnly), this._client);
     }
 
     /** @internal */
@@ -24128,7 +24365,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the container entrypoint */
     withEntrypoint(entrypoint: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withEntrypointInternal(entrypoint));
+        return new TestRedisResourcePromiseImpl(this._withEntrypointInternal(entrypoint), this._client);
     }
 
     /** @internal */
@@ -24143,7 +24380,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the container image tag */
     withImageTag(tag: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withImageTagInternal(tag));
+        return new TestRedisResourcePromiseImpl(this._withImageTagInternal(tag), this._client);
     }
 
     /** @internal */
@@ -24158,7 +24395,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the container image registry */
     withImageRegistry(registry: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withImageRegistryInternal(registry));
+        return new TestRedisResourcePromiseImpl(this._withImageRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -24175,7 +24412,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     /** Sets the container image */
     withImage(image: string, options?: WithImageOptions): TestRedisResourcePromise {
         const tag = options?.tag;
-        return new TestRedisResourcePromiseImpl(this._withImageInternal(image, tag));
+        return new TestRedisResourcePromiseImpl(this._withImageInternal(image, tag), this._client);
     }
 
     /** @internal */
@@ -24190,7 +24427,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the image SHA256 digest */
     withImageSHA256(sha256: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withImageSHA256Internal(sha256));
+        return new TestRedisResourcePromiseImpl(this._withImageSHA256Internal(sha256), this._client);
     }
 
     /** @internal */
@@ -24205,7 +24442,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Adds runtime arguments for the container */
     withContainerRuntimeArgs(args: string[]): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withContainerRuntimeArgsInternal(args));
+        return new TestRedisResourcePromiseImpl(this._withContainerRuntimeArgsInternal(args), this._client);
     }
 
     /** @internal */
@@ -24220,7 +24457,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the lifetime behavior of the container resource */
     withLifetime(lifetime: ContainerLifetime): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withLifetimeInternal(lifetime));
+        return new TestRedisResourcePromiseImpl(this._withLifetimeInternal(lifetime), this._client);
     }
 
     /** @internal */
@@ -24235,7 +24472,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the container image pull policy */
     withImagePullPolicy(pullPolicy: ImagePullPolicy): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withImagePullPolicyInternal(pullPolicy));
+        return new TestRedisResourcePromiseImpl(this._withImagePullPolicyInternal(pullPolicy), this._client);
     }
 
     /** @internal */
@@ -24250,7 +24487,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures the resource to be published as a container */
     publishAsContainer(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._publishAsContainerInternal());
+        return new TestRedisResourcePromiseImpl(this._publishAsContainerInternal(), this._client);
     }
 
     /** @internal */
@@ -24269,7 +24506,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     withDockerfile(contextPath: string, options?: WithDockerfileOptions): TestRedisResourcePromise {
         const dockerfilePath = options?.dockerfilePath;
         const stage = options?.stage;
-        return new TestRedisResourcePromiseImpl(this._withDockerfileInternal(contextPath, dockerfilePath, stage));
+        return new TestRedisResourcePromiseImpl(this._withDockerfileInternal(contextPath, dockerfilePath, stage), this._client);
     }
 
     /** @internal */
@@ -24284,11 +24521,12 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the container name */
     withContainerName(name: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withContainerNameInternal(name));
+        return new TestRedisResourcePromiseImpl(this._withContainerNameInternal(name), this._client);
     }
 
     /** @internal */
-    private async _withBuildArgInternal(name: string, value: ParameterResource): Promise<TestRedisResource> {
+    private async _withBuildArgInternal(name: string, value: Awaitable<ParameterResource>): Promise<TestRedisResource> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting/withParameterBuildArg',
@@ -24298,12 +24536,13 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Adds a build argument from a parameter resource */
-    withBuildArg(name: string, value: ParameterResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withBuildArgInternal(name, value));
+    withBuildArg(name: string, value: Awaitable<ParameterResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._withBuildArgInternal(name, value), this._client);
     }
 
     /** @internal */
-    private async _withBuildSecretInternal(name: string, value: ParameterResource): Promise<TestRedisResource> {
+    private async _withBuildSecretInternal(name: string, value: Awaitable<ParameterResource>): Promise<TestRedisResource> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting/withParameterBuildSecret',
@@ -24313,8 +24552,8 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Adds a build secret from a parameter resource */
-    withBuildSecret(name: string, value: ParameterResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withBuildSecretInternal(name, value));
+    withBuildSecret(name: string, value: Awaitable<ParameterResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._withBuildSecretInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -24329,7 +24568,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures endpoint proxy support */
     withEndpointProxySupport(proxyEnabled: boolean): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withEndpointProxySupportInternal(proxyEnabled));
+        return new TestRedisResourcePromiseImpl(this._withEndpointProxySupportInternal(proxyEnabled), this._client);
     }
 
     /** @internal */
@@ -24348,7 +24587,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): TestRedisResourcePromise {
         const buildImage = options?.buildImage;
         const runtimeImage = options?.runtimeImage;
-        return new TestRedisResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage));
+        return new TestRedisResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage), this._client);
     }
 
     /** @internal */
@@ -24363,7 +24602,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Adds a network alias for the container */
     withContainerNetworkAlias(alias: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withContainerNetworkAliasInternal(alias));
+        return new TestRedisResourcePromiseImpl(this._withContainerNetworkAliasInternal(alias), this._client);
     }
 
     /** @internal */
@@ -24382,7 +24621,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     withMcpServer(options?: WithMcpServerOptions): TestRedisResourcePromise {
         const path = options?.path;
         const endpointName = options?.endpointName;
-        return new TestRedisResourcePromiseImpl(this._withMcpServerInternal(path, endpointName));
+        return new TestRedisResourcePromiseImpl(this._withMcpServerInternal(path, endpointName), this._client);
     }
 
     /** @internal */
@@ -24397,7 +24636,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withOtlpExporterInternal());
+        return new TestRedisResourcePromiseImpl(this._withOtlpExporterInternal(), this._client);
     }
 
     /** @internal */
@@ -24412,7 +24651,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withOtlpExporterProtocolInternal(protocol));
+        return new TestRedisResourcePromiseImpl(this._withOtlpExporterProtocolInternal(protocol), this._client);
     }
 
     /** @internal */
@@ -24427,7 +24666,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Publishes the resource as a connection string */
     publishAsConnectionString(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._publishAsConnectionStringInternal());
+        return new TestRedisResourcePromiseImpl(this._publishAsConnectionStringInternal(), this._client);
     }
 
     /** @internal */
@@ -24444,11 +24683,12 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): TestRedisResourcePromise {
         const helpLink = options?.helpLink;
-        return new TestRedisResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink));
+        return new TestRedisResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): Promise<TestRedisResource> {
+    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): Promise<TestRedisResource> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting/withEnvironment',
@@ -24458,8 +24698,8 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withEnvironmentInternal(name, value));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._withEnvironmentInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -24477,7 +24717,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withEnvironmentExpressionInternal(name, value));
+        return new TestRedisResourcePromiseImpl(this._withEnvironmentExpressionInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -24497,11 +24737,12 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withEnvironmentCallbackInternal(callback));
+        return new TestRedisResourcePromiseImpl(this._withEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentEndpointInternal(name: string, endpointReference: EndpointReference): Promise<TestRedisResource> {
+    private async _withEnvironmentEndpointInternal(name: string, endpointReference: Awaitable<EndpointReference>): Promise<TestRedisResource> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, endpointReference };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting/withEnvironmentEndpoint',
@@ -24514,12 +24755,13 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentParameterInternal(name: string, parameter: ParameterResource): Promise<TestRedisResource> {
+    private async _withEnvironmentParameterInternal(name: string, parameter: Awaitable<ParameterResource>): Promise<TestRedisResource> {
+        parameter = isPromiseLike(parameter) ? await parameter : parameter;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, parameter };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting/withEnvironmentParameter',
@@ -24532,12 +24774,13 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withEnvironmentParameterInternal(name, parameter));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._withEnvironmentParameterInternal(name, parameter), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<TestRedisResource> {
+    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<TestRedisResource> {
+        resource = isPromiseLike(resource) ? await resource : resource;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, envVarName, resource };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting/withEnvironmentConnectionString',
@@ -24550,8 +24793,8 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource), this._client);
     }
 
     /** @internal */
@@ -24566,7 +24809,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Adds a connection property with a reference expression */
     withConnectionProperty(name: string, value: ReferenceExpression): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withConnectionPropertyInternal(name, value));
+        return new TestRedisResourcePromiseImpl(this._withConnectionPropertyInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -24581,7 +24824,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Adds a connection property with a string value */
     withConnectionPropertyValue(name: string, value: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withConnectionPropertyValueInternal(name, value));
+        return new TestRedisResourcePromiseImpl(this._withConnectionPropertyValueInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -24596,7 +24839,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Adds arguments */
     withArgs(args: string[]): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withArgsInternal(args));
+        return new TestRedisResourcePromiseImpl(this._withArgsInternal(args), this._client);
     }
 
     /** @internal */
@@ -24616,11 +24859,12 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withArgsCallbackInternal(callback));
+        return new TestRedisResourcePromiseImpl(this._withArgsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withReferenceInternal(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, connectionName?: string, optional?: boolean, name?: string): Promise<TestRedisResource> {
+    private async _withReferenceInternal(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, connectionName?: string, optional?: boolean, name?: string): Promise<TestRedisResource> {
+        source = isPromiseLike(source) ? await source : source;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, source };
         if (connectionName !== undefined) rpcArgs.connectionName = connectionName;
         if (optional !== undefined) rpcArgs.optional = optional;
@@ -24633,11 +24877,11 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): TestRedisResourcePromise {
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): TestRedisResourcePromise {
         const connectionName = options?.connectionName;
         const optional = options?.optional;
         const name = options?.name;
-        return new TestRedisResourcePromiseImpl(this._withReferenceInternal(source, connectionName, optional, name));
+        return new TestRedisResourcePromiseImpl(this._withReferenceInternal(source, connectionName, optional, name), this._client);
     }
 
     /** Gets a connection property by key */
@@ -24661,11 +24905,12 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withReferenceUriInternal(name, uri));
+        return new TestRedisResourcePromiseImpl(this._withReferenceUriInternal(name, uri), this._client);
     }
 
     /** @internal */
-    private async _withReferenceExternalServiceInternal(externalService: ExternalServiceResource): Promise<TestRedisResource> {
+    private async _withReferenceExternalServiceInternal(externalService: Awaitable<ExternalServiceResource>): Promise<TestRedisResource> {
+        externalService = isPromiseLike(externalService) ? await externalService : externalService;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, externalService };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting/withReferenceExternalService',
@@ -24675,12 +24920,13 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withReferenceExternalServiceInternal(externalService));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._withReferenceExternalServiceInternal(externalService), this._client);
     }
 
     /** @internal */
-    private async _withReferenceEndpointInternal(endpointReference: EndpointReference): Promise<TestRedisResource> {
+    private async _withReferenceEndpointInternal(endpointReference: Awaitable<EndpointReference>): Promise<TestRedisResource> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, endpointReference };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting/withReferenceEndpoint',
@@ -24690,8 +24936,8 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withReferenceEndpointInternal(endpointReference));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._withReferenceEndpointInternal(endpointReference), this._client);
     }
 
     /** @internal */
@@ -24722,7 +24968,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
         const isProxied = options?.isProxied;
         const isExternal = options?.isExternal;
         const protocol = options?.protocol;
-        return new TestRedisResourcePromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol));
+        return new TestRedisResourcePromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol), this._client);
     }
 
     /** @internal */
@@ -24747,7 +24993,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new TestRedisResourcePromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied));
+        return new TestRedisResourcePromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -24772,7 +25018,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new TestRedisResourcePromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied));
+        return new TestRedisResourcePromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -24787,7 +25033,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withExternalHttpEndpointsInternal());
+        return new TestRedisResourcePromiseImpl(this._withExternalHttpEndpointsInternal(), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -24811,7 +25057,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._asHttp2ServiceInternal());
+        return new TestRedisResourcePromiseImpl(this._asHttp2ServiceInternal(), this._client);
     }
 
     /** @internal */
@@ -24831,7 +25077,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withUrlsCallbackInternal(callback));
+        return new TestRedisResourcePromiseImpl(this._withUrlsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -24848,7 +25094,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): TestRedisResourcePromise {
         const displayText = options?.displayText;
-        return new TestRedisResourcePromiseImpl(this._withUrlInternal(url, displayText));
+        return new TestRedisResourcePromiseImpl(this._withUrlInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -24865,7 +25111,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): TestRedisResourcePromise {
         const displayText = options?.displayText;
-        return new TestRedisResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText));
+        return new TestRedisResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -24884,7 +25130,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback));
+        return new TestRedisResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -24904,7 +25150,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback));
+        return new TestRedisResourcePromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -24919,11 +25165,12 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._excludeFromManifestInternal());
+        return new TestRedisResourcePromiseImpl(this._excludeFromManifestInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestRedisResource> {
+    private async _waitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestRedisResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting/waitForResource',
@@ -24933,12 +25180,13 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._waitForInternal(dependency));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._waitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<TestRedisResource> {
+    private async _waitForWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<TestRedisResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting/waitForWithBehavior',
@@ -24948,12 +25196,13 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
-    private async _waitForStartInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestRedisResource> {
+    private async _waitForStartInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestRedisResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting/waitForResourceStart',
@@ -24963,12 +25212,13 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._waitForStartInternal(dependency));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._waitForStartInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForStartWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<TestRedisResource> {
+    private async _waitForStartWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<TestRedisResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting/waitForStartWithBehavior',
@@ -24978,8 +25228,8 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
@@ -24994,11 +25244,12 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withExplicitStartInternal());
+        return new TestRedisResourcePromiseImpl(this._withExplicitStartInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForCompletionInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, exitCode?: number): Promise<TestRedisResource> {
+    private async _waitForCompletionInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, exitCode?: number): Promise<TestRedisResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         if (exitCode !== undefined) rpcArgs.exitCode = exitCode;
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
@@ -25009,9 +25260,9 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): TestRedisResourcePromise {
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): TestRedisResourcePromise {
         const exitCode = options?.exitCode;
-        return new TestRedisResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode));
+        return new TestRedisResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode), this._client);
     }
 
     /** @internal */
@@ -25026,7 +25277,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Adds a health check by key */
     withHealthCheck(key: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withHealthCheckInternal(key));
+        return new TestRedisResourcePromiseImpl(this._withHealthCheckInternal(key), this._client);
     }
 
     /** @internal */
@@ -25047,7 +25298,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
         const path = options?.path;
         const statusCode = options?.statusCode;
         const endpointName = options?.endpointName;
-        return new TestRedisResourcePromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName));
+        return new TestRedisResourcePromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName), this._client);
     }
 
     /** @internal */
@@ -25069,7 +25320,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): TestRedisResourcePromise {
         const commandOptions = options?.commandOptions;
-        return new TestRedisResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions));
+        return new TestRedisResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions), this._client);
     }
 
     /** @internal */
@@ -25084,7 +25335,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withDeveloperCertificateTrustInternal(trust));
+        return new TestRedisResourcePromiseImpl(this._withDeveloperCertificateTrustInternal(trust), this._client);
     }
 
     /** @internal */
@@ -25099,11 +25350,12 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withCertificateTrustScopeInternal(scope));
+        return new TestRedisResourcePromiseImpl(this._withCertificateTrustScopeInternal(scope), this._client);
     }
 
     /** @internal */
-    private async _withHttpsDeveloperCertificateInternal(password?: ParameterResource): Promise<TestRedisResource> {
+    private async _withHttpsDeveloperCertificateInternal(password?: Awaitable<ParameterResource>): Promise<TestRedisResource> {
+        password = isPromiseLike(password) ? await password : password;
         const rpcArgs: Record<string, unknown> = { builder: this._handle };
         if (password !== undefined) rpcArgs.password = password;
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
@@ -25115,8 +25367,8 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): TestRedisResourcePromise {
-        const password = options?.password;
-        return new TestRedisResourcePromiseImpl(this._withHttpsDeveloperCertificateInternal(password));
+        let password = options?.password;
+        return new TestRedisResourcePromiseImpl(this._withHttpsDeveloperCertificateInternal(password), this._client);
     }
 
     /** @internal */
@@ -25131,11 +25383,12 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withoutHttpsCertificateInternal());
+        return new TestRedisResourcePromiseImpl(this._withoutHttpsCertificateInternal(), this._client);
     }
 
     /** @internal */
-    private async _withParentRelationshipInternal(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestRedisResource> {
+    private async _withParentRelationshipInternal(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestRedisResource> {
+        parent = isPromiseLike(parent) ? await parent : parent;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, parent };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting/withBuilderParentRelationship',
@@ -25145,12 +25398,13 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withParentRelationshipInternal(parent));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._withParentRelationshipInternal(parent), this._client);
     }
 
     /** @internal */
-    private async _withChildRelationshipInternal(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestRedisResource> {
+    private async _withChildRelationshipInternal(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestRedisResource> {
+        child = isPromiseLike(child) ? await child : child;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, child };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting/withBuilderChildRelationship',
@@ -25160,8 +25414,8 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withChildRelationshipInternal(child));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._withChildRelationshipInternal(child), this._client);
     }
 
     /** @internal */
@@ -25178,7 +25432,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): TestRedisResourcePromise {
         const iconVariant = options?.iconVariant;
-        return new TestRedisResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant));
+        return new TestRedisResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant), this._client);
     }
 
     /** @internal */
@@ -25207,7 +25461,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
         const failureThreshold = options?.failureThreshold;
         const successThreshold = options?.successThreshold;
         const endpointName = options?.endpointName;
-        return new TestRedisResourcePromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName));
+        return new TestRedisResourcePromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName), this._client);
     }
 
     /** @internal */
@@ -25222,7 +25476,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._excludeFromMcpInternal());
+        return new TestRedisResourcePromiseImpl(this._excludeFromMcpInternal(), this._client);
     }
 
     /** @internal */
@@ -25237,7 +25491,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName));
+        return new TestRedisResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName), this._client);
     }
 
     /** @internal */
@@ -25252,7 +25506,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag));
+        return new TestRedisResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag), this._client);
     }
 
     /** @internal */
@@ -25280,7 +25534,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
         const requiredBy = options?.requiredBy;
         const tags = options?.tags;
         const description = options?.description;
-        return new TestRedisResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description));
+        return new TestRedisResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description), this._client);
     }
 
     /** @internal */
@@ -25300,7 +25554,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withPipelineConfigurationInternal(callback));
+        return new TestRedisResourcePromiseImpl(this._withPipelineConfigurationInternal(callback), this._client);
     }
 
     /** @internal */
@@ -25319,7 +25573,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     withVolume(target: string, options?: WithVolumeOptions): TestRedisResourcePromise {
         const name = options?.name;
         const isReadOnly = options?.isReadOnly;
-        return new TestRedisResourcePromiseImpl(this._withVolumeInternal(target, name, isReadOnly));
+        return new TestRedisResourcePromiseImpl(this._withVolumeInternal(target, name, isReadOnly), this._client);
     }
 
     /** Gets the resource name */
@@ -25348,7 +25602,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback));
+        return new TestRedisResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -25368,7 +25622,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._onResourceStoppedInternal(callback));
+        return new TestRedisResourcePromiseImpl(this._onResourceStoppedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -25388,7 +25642,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Subscribes to the ConnectionStringAvailable event */
     onConnectionStringAvailable(callback: (arg: ConnectionStringAvailableEvent) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._onConnectionStringAvailableInternal(callback));
+        return new TestRedisResourcePromiseImpl(this._onConnectionStringAvailableInternal(callback), this._client);
     }
 
     /** @internal */
@@ -25408,7 +25662,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._onInitializeResourceInternal(callback));
+        return new TestRedisResourcePromiseImpl(this._onInitializeResourceInternal(callback), this._client);
     }
 
     /** @internal */
@@ -25428,7 +25682,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._onResourceEndpointsAllocatedInternal(callback));
+        return new TestRedisResourcePromiseImpl(this._onResourceEndpointsAllocatedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -25448,7 +25702,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._onResourceReadyInternal(callback));
+        return new TestRedisResourcePromiseImpl(this._onResourceReadyInternal(callback), this._client);
     }
 
     /** @internal */
@@ -25465,7 +25719,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     /** Adds a child database to a test Redis resource */
     addTestChildDatabase(name: string, options?: AddTestChildDatabaseOptions): TestDatabaseResourcePromise {
         const databaseName = options?.databaseName;
-        return new TestDatabaseResourcePromiseImpl(this._addTestChildDatabaseInternal(name, databaseName));
+        return new TestDatabaseResourcePromiseImpl(this._addTestChildDatabaseInternal(name, databaseName), this._client);
     }
 
     /** @internal */
@@ -25482,7 +25736,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     /** Configures the Redis resource with persistence */
     withPersistence(options?: WithPersistenceOptions): TestRedisResourcePromise {
         const mode = options?.mode;
-        return new TestRedisResourcePromiseImpl(this._withPersistenceInternal(mode));
+        return new TestRedisResourcePromiseImpl(this._withPersistenceInternal(mode), this._client);
     }
 
     /** @internal */
@@ -25501,7 +25755,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     withOptionalString(options?: WithOptionalStringOptions): TestRedisResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new TestRedisResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new TestRedisResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -25516,7 +25770,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withConfigInternal(config));
+        return new TestRedisResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** Gets the tags for the resource */
@@ -25549,7 +25803,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the connection string using a reference expression */
     withConnectionString(connectionString: ReferenceExpression): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withConnectionStringInternal(connectionString));
+        return new TestRedisResourcePromiseImpl(this._withConnectionStringInternal(connectionString), this._client);
     }
 
     /** @internal */
@@ -25569,7 +25823,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback));
+        return new TestRedisResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -25584,7 +25838,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new TestRedisResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -25599,7 +25853,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new TestRedisResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -25614,7 +25868,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new TestRedisResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -25636,7 +25890,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): TestRedisResourcePromise {
         const callback = options?.callback;
-        return new TestRedisResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new TestRedisResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -25651,7 +25905,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withStatusInternal(status));
+        return new TestRedisResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -25666,7 +25920,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new TestRedisResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -25686,11 +25940,12 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new TestRedisResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestRedisResource> {
+    private async _testWaitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestRedisResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -25700,8 +25955,8 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** Gets the endpoints */
@@ -25725,7 +25980,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets connection string using direct interface target */
     withConnectionStringDirect(connectionString: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withConnectionStringDirectInternal(connectionString));
+        return new TestRedisResourcePromiseImpl(this._withConnectionStringDirectInternal(connectionString), this._client);
     }
 
     /** @internal */
@@ -25740,11 +25995,12 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Redis-specific configuration */
     withRedisSpecific(option: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withRedisSpecificInternal(option));
+        return new TestRedisResourcePromiseImpl(this._withRedisSpecificInternal(option), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<TestRedisResource> {
+    private async _withDependencyInternal(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<TestRedisResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -25754,12 +26010,13 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<TestRedisResource> {
+    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<TestRedisResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestRedisResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -25769,8 +26026,8 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -25785,7 +26042,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new TestRedisResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -25800,7 +26057,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables));
+        return new TestRedisResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables), this._client);
     }
 
     /** Gets the status of the resource asynchronously */
@@ -25830,7 +26087,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new TestRedisResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** Waits for the resource to be ready */
@@ -25863,7 +26120,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Tests multi-param callback destructuring */
     withMultiParamHandleCallback(callback: (arg1: TestCallbackContext, arg2: TestEnvironmentContext) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withMultiParamHandleCallbackInternal(callback));
+        return new TestRedisResourcePromiseImpl(this._withMultiParamHandleCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -25882,7 +26139,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     withDataVolume(options?: WithDataVolumeOptions): TestRedisResourcePromise {
         const name = options?.name;
         const isReadOnly = options?.isReadOnly;
-        return new TestRedisResourcePromiseImpl(this._withDataVolumeInternal(name, isReadOnly));
+        return new TestRedisResourcePromiseImpl(this._withDataVolumeInternal(name, isReadOnly), this._client);
     }
 
     /** @internal */
@@ -25897,7 +26154,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new TestRedisResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -25912,7 +26169,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new TestRedisResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -25927,7 +26184,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new TestRedisResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -25942,7 +26199,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new TestRedisResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -25961,7 +26218,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): TestRedisResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new TestRedisResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new TestRedisResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -25980,7 +26237,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): TestRedisResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new TestRedisResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new TestRedisResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -25995,7 +26252,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new TestRedisResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -26010,7 +26267,7 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new TestRedisResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -26021,7 +26278,9 @@ class TestRedisResourceImpl extends ResourceBuilderBase<TestRedisResourceHandle>
  * await builder.addSomething().withX().withY();
  */
 class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
-    constructor(private _promise: Promise<TestRedisResource>) {}
+    constructor(private _promise: Promise<TestRedisResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = TestRedisResource, TResult2 = never>(
         onfulfilled?: ((value: TestRedisResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -26031,123 +26290,123 @@ class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)), this._client);
     }
 
     /** Adds a bind mount */
     withBindMount(source: string, target: string, options?: WithBindMountOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withBindMount(source, target, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withBindMount(source, target, options)), this._client);
     }
 
     /** Sets the container entrypoint */
     withEntrypoint(entrypoint: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEntrypoint(entrypoint)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEntrypoint(entrypoint)), this._client);
     }
 
     /** Sets the container image tag */
     withImageTag(tag: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withImageTag(tag)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withImageTag(tag)), this._client);
     }
 
     /** Sets the container image registry */
     withImageRegistry(registry: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withImageRegistry(registry)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withImageRegistry(registry)), this._client);
     }
 
     /** Sets the container image */
     withImage(image: string, options?: WithImageOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withImage(image, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withImage(image, options)), this._client);
     }
 
     /** Sets the image SHA256 digest */
     withImageSHA256(sha256: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withImageSHA256(sha256)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withImageSHA256(sha256)), this._client);
     }
 
     /** Adds runtime arguments for the container */
     withContainerRuntimeArgs(args: string[]): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withContainerRuntimeArgs(args)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withContainerRuntimeArgs(args)), this._client);
     }
 
     /** Sets the lifetime behavior of the container resource */
     withLifetime(lifetime: ContainerLifetime): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withLifetime(lifetime)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withLifetime(lifetime)), this._client);
     }
 
     /** Sets the container image pull policy */
     withImagePullPolicy(pullPolicy: ImagePullPolicy): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withImagePullPolicy(pullPolicy)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withImagePullPolicy(pullPolicy)), this._client);
     }
 
     /** Configures the resource to be published as a container */
     publishAsContainer(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.publishAsContainer()));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.publishAsContainer()), this._client);
     }
 
     /** Configures the resource to use a Dockerfile */
     withDockerfile(contextPath: string, options?: WithDockerfileOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withDockerfile(contextPath, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withDockerfile(contextPath, options)), this._client);
     }
 
     /** Sets the container name */
     withContainerName(name: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withContainerName(name)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withContainerName(name)), this._client);
     }
 
     /** Adds a build argument from a parameter resource */
-    withBuildArg(name: string, value: ParameterResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withBuildArg(name, value)));
+    withBuildArg(name: string, value: Awaitable<ParameterResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withBuildArg(name, value)), this._client);
     }
 
     /** Adds a build secret from a parameter resource */
-    withBuildSecret(name: string, value: ParameterResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withBuildSecret(name, value)));
+    withBuildSecret(name: string, value: Awaitable<ParameterResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withBuildSecret(name, value)), this._client);
     }
 
     /** Configures endpoint proxy support */
     withEndpointProxySupport(proxyEnabled: boolean): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEndpointProxySupport(proxyEnabled)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEndpointProxySupport(proxyEnabled)), this._client);
     }
 
     /** Sets the base image for a Dockerfile build */
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)), this._client);
     }
 
     /** Adds a network alias for the container */
     withContainerNetworkAlias(alias: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withContainerNetworkAlias(alias)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withContainerNetworkAlias(alias)), this._client);
     }
 
     /** Configures an MCP server endpoint on the resource */
     withMcpServer(options?: WithMcpServerOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMcpServer(options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMcpServer(options)), this._client);
     }
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporter()));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporter()), this._client);
     }
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)), this._client);
     }
 
     /** Publishes the resource as a connection string */
     publishAsConnectionString(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.publishAsConnectionString()));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.publishAsConnectionString()), this._client);
     }
 
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)), this._client);
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)), this._client);
     }
 
     /**
@@ -26155,61 +26414,61 @@ class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)), this._client);
     }
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)), this._client);
     }
 
     /**
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)), this._client);
     }
 
     /**
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)), this._client);
     }
 
     /**
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)), this._client);
     }
 
     /** Adds a connection property with a reference expression */
     withConnectionProperty(name: string, value: ReferenceExpression): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withConnectionProperty(name, value)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withConnectionProperty(name, value)), this._client);
     }
 
     /** Adds a connection property with a string value */
     withConnectionPropertyValue(name: string, value: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withConnectionPropertyValue(name, value)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withConnectionPropertyValue(name, value)), this._client);
     }
 
     /** Adds arguments */
     withArgs(args: string[]): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withArgs(args)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withArgs(args)), this._client);
     }
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)), this._client);
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withReference(source, options)));
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withReference(source, options)), this._client);
     }
 
     /** Gets a connection property by key */
@@ -26219,37 +26478,37 @@ class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)), this._client);
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)), this._client);
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)), this._client);
     }
 
     /** Adds a network endpoint */
     withEndpoint(options?: WithEndpointOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEndpoint(options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEndpoint(options)), this._client);
     }
 
     /** Adds an HTTP endpoint */
     withHttpEndpoint(options?: WithHttpEndpointOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)), this._client);
     }
 
     /** Adds an HTTPS endpoint */
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)), this._client);
     }
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -26259,152 +26518,152 @@ class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.asHttp2Service()));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.asHttp2Service()), this._client);
     }
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)), this._client);
     }
 
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)), this._client);
     }
 
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)), this._client);
     }
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)), this._client);
     }
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)), this._client);
     }
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()), this._client);
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)), this._client);
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)), this._client);
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()), this._client);
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)));
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)), this._client);
     }
 
     /** Adds a health check by key */
     withHealthCheck(key: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)), this._client);
     }
 
     /** Adds an HTTP health check */
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)), this._client);
     }
 
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)), this._client);
     }
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)), this._client);
     }
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)), this._client);
     }
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)), this._client);
     }
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()), this._client);
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)), this._client);
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)), this._client);
     }
 
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)), this._client);
     }
 
     /** Adds an HTTP health probe to the resource */
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)), this._client);
     }
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()), this._client);
     }
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)), this._client);
     }
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)), this._client);
     }
 
     /** Adds a pipeline step to the resource */
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)), this._client);
     }
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)), this._client);
     }
 
     /** Adds a volume */
     withVolume(target: string, options?: WithVolumeOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withVolume(target, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withVolume(target, options)), this._client);
     }
 
     /** Gets the resource name */
@@ -26414,52 +26673,52 @@ class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)), this._client);
     }
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)), this._client);
     }
 
     /** Subscribes to the ConnectionStringAvailable event */
     onConnectionStringAvailable(callback: (arg: ConnectionStringAvailableEvent) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.onConnectionStringAvailable(callback)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.onConnectionStringAvailable(callback)), this._client);
     }
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)), this._client);
     }
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)), this._client);
     }
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)), this._client);
     }
 
     /** Adds a child database to a test Redis resource */
     addTestChildDatabase(name: string, options?: AddTestChildDatabaseOptions): TestDatabaseResourcePromise {
-        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.addTestChildDatabase(name, options)));
+        return new TestDatabaseResourcePromiseImpl(this._promise.then(obj => obj.addTestChildDatabase(name, options)), this._client);
     }
 
     /** Configures the Redis resource with persistence */
     withPersistence(options?: WithPersistenceOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withPersistence(options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withPersistence(options)), this._client);
     }
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Gets the tags for the resource */
@@ -26474,52 +26733,52 @@ class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
 
     /** Sets the connection string using a reference expression */
     withConnectionString(connectionString: ReferenceExpression): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withConnectionString(connectionString)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withConnectionString(connectionString)), this._client);
     }
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Gets the endpoints */
@@ -26529,32 +26788,32 @@ class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
 
     /** Sets connection string using direct interface target */
     withConnectionStringDirect(connectionString: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withConnectionStringDirect(connectionString)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withConnectionStringDirect(connectionString)), this._client);
     }
 
     /** Redis-specific configuration */
     withRedisSpecific(option: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withRedisSpecific(option)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withRedisSpecific(option)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestRedisResourcePromise {
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)), this._client);
     }
 
     /** Gets the status of the resource asynchronously */
@@ -26564,7 +26823,7 @@ class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Waits for the resource to be ready */
@@ -26574,52 +26833,52 @@ class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
 
     /** Tests multi-param callback destructuring */
     withMultiParamHandleCallback(callback: (arg1: TestCallbackContext, arg2: TestEnvironmentContext) => Promise<void>): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMultiParamHandleCallback(callback)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMultiParamHandleCallback(callback)), this._client);
     }
 
     /** Adds a data volume with persistence */
     withDataVolume(options?: WithDataVolumeOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withDataVolume(options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withDataVolume(options)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): TestRedisResourcePromise {
-        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new TestRedisResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -26630,7 +26889,7 @@ class TestRedisResourcePromiseImpl implements TestRedisResourcePromise {
 
 export interface TestVaultResource {
     toJSON(): MarshalledHandle;
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise;
     withBindMount(source: string, target: string, options?: WithBindMountOptions): TestVaultResourcePromise;
     withEntrypoint(entrypoint: string): TestVaultResourcePromise;
     withImageTag(tag: string): TestVaultResourcePromise;
@@ -26643,8 +26902,8 @@ export interface TestVaultResource {
     publishAsContainer(): TestVaultResourcePromise;
     withDockerfile(contextPath: string, options?: WithDockerfileOptions): TestVaultResourcePromise;
     withContainerName(name: string): TestVaultResourcePromise;
-    withBuildArg(name: string, value: ParameterResource): TestVaultResourcePromise;
-    withBuildSecret(name: string, value: ParameterResource): TestVaultResourcePromise;
+    withBuildArg(name: string, value: Awaitable<ParameterResource>): TestVaultResourcePromise;
+    withBuildSecret(name: string, value: Awaitable<ParameterResource>): TestVaultResourcePromise;
     withEndpointProxySupport(proxyEnabled: boolean): TestVaultResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): TestVaultResourcePromise;
     withContainerNetworkAlias(alias: string): TestVaultResourcePromise;
@@ -26653,18 +26912,18 @@ export interface TestVaultResource {
     withOtlpExporterProtocol(protocol: OtlpProtocol): TestVaultResourcePromise;
     publishAsConnectionString(): TestVaultResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): TestVaultResourcePromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): TestVaultResourcePromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): TestVaultResourcePromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): TestVaultResourcePromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): TestVaultResourcePromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): TestVaultResourcePromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): TestVaultResourcePromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): TestVaultResourcePromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): TestVaultResourcePromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise;
     withArgs(args: string[]): TestVaultResourcePromise;
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): TestVaultResourcePromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): TestVaultResourcePromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): TestVaultResourcePromise;
     withReferenceUri(name: string, uri: string): TestVaultResourcePromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): TestVaultResourcePromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): TestVaultResourcePromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): TestVaultResourcePromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): TestVaultResourcePromise;
     withEndpoint(options?: WithEndpointOptions): TestVaultResourcePromise;
     withHttpEndpoint(options?: WithHttpEndpointOptions): TestVaultResourcePromise;
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): TestVaultResourcePromise;
@@ -26677,12 +26936,12 @@ export interface TestVaultResource {
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): TestVaultResourcePromise;
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): TestVaultResourcePromise;
     excludeFromManifest(): TestVaultResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestVaultResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestVaultResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestVaultResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestVaultResourcePromise;
     withExplicitStart(): TestVaultResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): TestVaultResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): TestVaultResourcePromise;
     withHealthCheck(key: string): TestVaultResourcePromise;
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): TestVaultResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): TestVaultResourcePromise;
@@ -26690,8 +26949,8 @@ export interface TestVaultResource {
     withCertificateTrustScope(scope: CertificateTrustScope): TestVaultResourcePromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): TestVaultResourcePromise;
     withoutHttpsCertificate(): TestVaultResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): TestVaultResourcePromise;
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): TestVaultResourcePromise;
     excludeFromMcp(): TestVaultResourcePromise;
@@ -26716,9 +26975,9 @@ export interface TestVaultResource {
     withStatus(status: TestResourceStatus): TestVaultResourcePromise;
     withNestedConfig(config: TestNestedDto): TestVaultResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestVaultResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise;
     withEndpoints(endpoints: string[]): TestVaultResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): TestVaultResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestVaultResourcePromise;
@@ -26734,7 +26993,7 @@ export interface TestVaultResource {
 }
 
 export interface TestVaultResourcePromise extends PromiseLike<TestVaultResource> {
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise;
     withBindMount(source: string, target: string, options?: WithBindMountOptions): TestVaultResourcePromise;
     withEntrypoint(entrypoint: string): TestVaultResourcePromise;
     withImageTag(tag: string): TestVaultResourcePromise;
@@ -26747,8 +27006,8 @@ export interface TestVaultResourcePromise extends PromiseLike<TestVaultResource>
     publishAsContainer(): TestVaultResourcePromise;
     withDockerfile(contextPath: string, options?: WithDockerfileOptions): TestVaultResourcePromise;
     withContainerName(name: string): TestVaultResourcePromise;
-    withBuildArg(name: string, value: ParameterResource): TestVaultResourcePromise;
-    withBuildSecret(name: string, value: ParameterResource): TestVaultResourcePromise;
+    withBuildArg(name: string, value: Awaitable<ParameterResource>): TestVaultResourcePromise;
+    withBuildSecret(name: string, value: Awaitable<ParameterResource>): TestVaultResourcePromise;
     withEndpointProxySupport(proxyEnabled: boolean): TestVaultResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): TestVaultResourcePromise;
     withContainerNetworkAlias(alias: string): TestVaultResourcePromise;
@@ -26757,18 +27016,18 @@ export interface TestVaultResourcePromise extends PromiseLike<TestVaultResource>
     withOtlpExporterProtocol(protocol: OtlpProtocol): TestVaultResourcePromise;
     publishAsConnectionString(): TestVaultResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): TestVaultResourcePromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): TestVaultResourcePromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): TestVaultResourcePromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): TestVaultResourcePromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): TestVaultResourcePromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): TestVaultResourcePromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): TestVaultResourcePromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): TestVaultResourcePromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): TestVaultResourcePromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise;
     withArgs(args: string[]): TestVaultResourcePromise;
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): TestVaultResourcePromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): TestVaultResourcePromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): TestVaultResourcePromise;
     withReferenceUri(name: string, uri: string): TestVaultResourcePromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): TestVaultResourcePromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): TestVaultResourcePromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): TestVaultResourcePromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): TestVaultResourcePromise;
     withEndpoint(options?: WithEndpointOptions): TestVaultResourcePromise;
     withHttpEndpoint(options?: WithHttpEndpointOptions): TestVaultResourcePromise;
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): TestVaultResourcePromise;
@@ -26781,12 +27040,12 @@ export interface TestVaultResourcePromise extends PromiseLike<TestVaultResource>
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): TestVaultResourcePromise;
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): TestVaultResourcePromise;
     excludeFromManifest(): TestVaultResourcePromise;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestVaultResourcePromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestVaultResourcePromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestVaultResourcePromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestVaultResourcePromise;
     withExplicitStart(): TestVaultResourcePromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): TestVaultResourcePromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): TestVaultResourcePromise;
     withHealthCheck(key: string): TestVaultResourcePromise;
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): TestVaultResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): TestVaultResourcePromise;
@@ -26794,8 +27053,8 @@ export interface TestVaultResourcePromise extends PromiseLike<TestVaultResource>
     withCertificateTrustScope(scope: CertificateTrustScope): TestVaultResourcePromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): TestVaultResourcePromise;
     withoutHttpsCertificate(): TestVaultResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): TestVaultResourcePromise;
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): TestVaultResourcePromise;
     excludeFromMcp(): TestVaultResourcePromise;
@@ -26820,9 +27079,9 @@ export interface TestVaultResourcePromise extends PromiseLike<TestVaultResource>
     withStatus(status: TestResourceStatus): TestVaultResourcePromise;
     withNestedConfig(config: TestNestedDto): TestVaultResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestVaultResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise;
     withEndpoints(endpoints: string[]): TestVaultResourcePromise;
     withEnvironmentVariables(variables: Record<string, string>): TestVaultResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestVaultResourcePromise;
@@ -26847,7 +27106,8 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** @internal */
-    private async _withContainerRegistryInternal(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestVaultResource> {
+    private async _withContainerRegistryInternal(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestVaultResource> {
+        registry = isPromiseLike(registry) ? await registry : registry;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, registry };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting/withContainerRegistry',
@@ -26857,8 +27117,8 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withContainerRegistryInternal(registry));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._withContainerRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -26875,7 +27135,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     /** Adds a bind mount */
     withBindMount(source: string, target: string, options?: WithBindMountOptions): TestVaultResourcePromise {
         const isReadOnly = options?.isReadOnly;
-        return new TestVaultResourcePromiseImpl(this._withBindMountInternal(source, target, isReadOnly));
+        return new TestVaultResourcePromiseImpl(this._withBindMountInternal(source, target, isReadOnly), this._client);
     }
 
     /** @internal */
@@ -26890,7 +27150,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the container entrypoint */
     withEntrypoint(entrypoint: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withEntrypointInternal(entrypoint));
+        return new TestVaultResourcePromiseImpl(this._withEntrypointInternal(entrypoint), this._client);
     }
 
     /** @internal */
@@ -26905,7 +27165,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the container image tag */
     withImageTag(tag: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withImageTagInternal(tag));
+        return new TestVaultResourcePromiseImpl(this._withImageTagInternal(tag), this._client);
     }
 
     /** @internal */
@@ -26920,7 +27180,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the container image registry */
     withImageRegistry(registry: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withImageRegistryInternal(registry));
+        return new TestVaultResourcePromiseImpl(this._withImageRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -26937,7 +27197,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     /** Sets the container image */
     withImage(image: string, options?: WithImageOptions): TestVaultResourcePromise {
         const tag = options?.tag;
-        return new TestVaultResourcePromiseImpl(this._withImageInternal(image, tag));
+        return new TestVaultResourcePromiseImpl(this._withImageInternal(image, tag), this._client);
     }
 
     /** @internal */
@@ -26952,7 +27212,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the image SHA256 digest */
     withImageSHA256(sha256: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withImageSHA256Internal(sha256));
+        return new TestVaultResourcePromiseImpl(this._withImageSHA256Internal(sha256), this._client);
     }
 
     /** @internal */
@@ -26967,7 +27227,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Adds runtime arguments for the container */
     withContainerRuntimeArgs(args: string[]): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withContainerRuntimeArgsInternal(args));
+        return new TestVaultResourcePromiseImpl(this._withContainerRuntimeArgsInternal(args), this._client);
     }
 
     /** @internal */
@@ -26982,7 +27242,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the lifetime behavior of the container resource */
     withLifetime(lifetime: ContainerLifetime): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withLifetimeInternal(lifetime));
+        return new TestVaultResourcePromiseImpl(this._withLifetimeInternal(lifetime), this._client);
     }
 
     /** @internal */
@@ -26997,7 +27257,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the container image pull policy */
     withImagePullPolicy(pullPolicy: ImagePullPolicy): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withImagePullPolicyInternal(pullPolicy));
+        return new TestVaultResourcePromiseImpl(this._withImagePullPolicyInternal(pullPolicy), this._client);
     }
 
     /** @internal */
@@ -27012,7 +27272,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures the resource to be published as a container */
     publishAsContainer(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._publishAsContainerInternal());
+        return new TestVaultResourcePromiseImpl(this._publishAsContainerInternal(), this._client);
     }
 
     /** @internal */
@@ -27031,7 +27291,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     withDockerfile(contextPath: string, options?: WithDockerfileOptions): TestVaultResourcePromise {
         const dockerfilePath = options?.dockerfilePath;
         const stage = options?.stage;
-        return new TestVaultResourcePromiseImpl(this._withDockerfileInternal(contextPath, dockerfilePath, stage));
+        return new TestVaultResourcePromiseImpl(this._withDockerfileInternal(contextPath, dockerfilePath, stage), this._client);
     }
 
     /** @internal */
@@ -27046,11 +27306,12 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the container name */
     withContainerName(name: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withContainerNameInternal(name));
+        return new TestVaultResourcePromiseImpl(this._withContainerNameInternal(name), this._client);
     }
 
     /** @internal */
-    private async _withBuildArgInternal(name: string, value: ParameterResource): Promise<TestVaultResource> {
+    private async _withBuildArgInternal(name: string, value: Awaitable<ParameterResource>): Promise<TestVaultResource> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting/withParameterBuildArg',
@@ -27060,12 +27321,13 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Adds a build argument from a parameter resource */
-    withBuildArg(name: string, value: ParameterResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withBuildArgInternal(name, value));
+    withBuildArg(name: string, value: Awaitable<ParameterResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._withBuildArgInternal(name, value), this._client);
     }
 
     /** @internal */
-    private async _withBuildSecretInternal(name: string, value: ParameterResource): Promise<TestVaultResource> {
+    private async _withBuildSecretInternal(name: string, value: Awaitable<ParameterResource>): Promise<TestVaultResource> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting/withParameterBuildSecret',
@@ -27075,8 +27337,8 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Adds a build secret from a parameter resource */
-    withBuildSecret(name: string, value: ParameterResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withBuildSecretInternal(name, value));
+    withBuildSecret(name: string, value: Awaitable<ParameterResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._withBuildSecretInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -27091,7 +27353,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures endpoint proxy support */
     withEndpointProxySupport(proxyEnabled: boolean): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withEndpointProxySupportInternal(proxyEnabled));
+        return new TestVaultResourcePromiseImpl(this._withEndpointProxySupportInternal(proxyEnabled), this._client);
     }
 
     /** @internal */
@@ -27110,7 +27372,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): TestVaultResourcePromise {
         const buildImage = options?.buildImage;
         const runtimeImage = options?.runtimeImage;
-        return new TestVaultResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage));
+        return new TestVaultResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage), this._client);
     }
 
     /** @internal */
@@ -27125,7 +27387,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Adds a network alias for the container */
     withContainerNetworkAlias(alias: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withContainerNetworkAliasInternal(alias));
+        return new TestVaultResourcePromiseImpl(this._withContainerNetworkAliasInternal(alias), this._client);
     }
 
     /** @internal */
@@ -27144,7 +27406,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     withMcpServer(options?: WithMcpServerOptions): TestVaultResourcePromise {
         const path = options?.path;
         const endpointName = options?.endpointName;
-        return new TestVaultResourcePromiseImpl(this._withMcpServerInternal(path, endpointName));
+        return new TestVaultResourcePromiseImpl(this._withMcpServerInternal(path, endpointName), this._client);
     }
 
     /** @internal */
@@ -27159,7 +27421,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withOtlpExporterInternal());
+        return new TestVaultResourcePromiseImpl(this._withOtlpExporterInternal(), this._client);
     }
 
     /** @internal */
@@ -27174,7 +27436,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withOtlpExporterProtocolInternal(protocol));
+        return new TestVaultResourcePromiseImpl(this._withOtlpExporterProtocolInternal(protocol), this._client);
     }
 
     /** @internal */
@@ -27189,7 +27451,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Publishes the resource as a connection string */
     publishAsConnectionString(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._publishAsConnectionStringInternal());
+        return new TestVaultResourcePromiseImpl(this._publishAsConnectionStringInternal(), this._client);
     }
 
     /** @internal */
@@ -27206,11 +27468,12 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): TestVaultResourcePromise {
         const helpLink = options?.helpLink;
-        return new TestVaultResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink));
+        return new TestVaultResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): Promise<TestVaultResource> {
+    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): Promise<TestVaultResource> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting/withEnvironment',
@@ -27220,8 +27483,8 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withEnvironmentInternal(name, value));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._withEnvironmentInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -27239,7 +27502,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withEnvironmentExpressionInternal(name, value));
+        return new TestVaultResourcePromiseImpl(this._withEnvironmentExpressionInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -27259,11 +27522,12 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withEnvironmentCallbackInternal(callback));
+        return new TestVaultResourcePromiseImpl(this._withEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentEndpointInternal(name: string, endpointReference: EndpointReference): Promise<TestVaultResource> {
+    private async _withEnvironmentEndpointInternal(name: string, endpointReference: Awaitable<EndpointReference>): Promise<TestVaultResource> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, endpointReference };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting/withEnvironmentEndpoint',
@@ -27276,12 +27540,13 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentParameterInternal(name: string, parameter: ParameterResource): Promise<TestVaultResource> {
+    private async _withEnvironmentParameterInternal(name: string, parameter: Awaitable<ParameterResource>): Promise<TestVaultResource> {
+        parameter = isPromiseLike(parameter) ? await parameter : parameter;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, parameter };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting/withEnvironmentParameter',
@@ -27294,12 +27559,13 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withEnvironmentParameterInternal(name, parameter));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._withEnvironmentParameterInternal(name, parameter), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<TestVaultResource> {
+    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<TestVaultResource> {
+        resource = isPromiseLike(resource) ? await resource : resource;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, envVarName, resource };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting/withEnvironmentConnectionString',
@@ -27312,8 +27578,8 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource), this._client);
     }
 
     /** @internal */
@@ -27328,7 +27594,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Adds arguments */
     withArgs(args: string[]): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withArgsInternal(args));
+        return new TestVaultResourcePromiseImpl(this._withArgsInternal(args), this._client);
     }
 
     /** @internal */
@@ -27348,11 +27614,12 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withArgsCallbackInternal(callback));
+        return new TestVaultResourcePromiseImpl(this._withArgsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withReferenceInternal(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, connectionName?: string, optional?: boolean, name?: string): Promise<TestVaultResource> {
+    private async _withReferenceInternal(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, connectionName?: string, optional?: boolean, name?: string): Promise<TestVaultResource> {
+        source = isPromiseLike(source) ? await source : source;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, source };
         if (connectionName !== undefined) rpcArgs.connectionName = connectionName;
         if (optional !== undefined) rpcArgs.optional = optional;
@@ -27365,11 +27632,11 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): TestVaultResourcePromise {
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): TestVaultResourcePromise {
         const connectionName = options?.connectionName;
         const optional = options?.optional;
         const name = options?.name;
-        return new TestVaultResourcePromiseImpl(this._withReferenceInternal(source, connectionName, optional, name));
+        return new TestVaultResourcePromiseImpl(this._withReferenceInternal(source, connectionName, optional, name), this._client);
     }
 
     /** @internal */
@@ -27384,11 +27651,12 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withReferenceUriInternal(name, uri));
+        return new TestVaultResourcePromiseImpl(this._withReferenceUriInternal(name, uri), this._client);
     }
 
     /** @internal */
-    private async _withReferenceExternalServiceInternal(externalService: ExternalServiceResource): Promise<TestVaultResource> {
+    private async _withReferenceExternalServiceInternal(externalService: Awaitable<ExternalServiceResource>): Promise<TestVaultResource> {
+        externalService = isPromiseLike(externalService) ? await externalService : externalService;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, externalService };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting/withReferenceExternalService',
@@ -27398,12 +27666,13 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withReferenceExternalServiceInternal(externalService));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._withReferenceExternalServiceInternal(externalService), this._client);
     }
 
     /** @internal */
-    private async _withReferenceEndpointInternal(endpointReference: EndpointReference): Promise<TestVaultResource> {
+    private async _withReferenceEndpointInternal(endpointReference: Awaitable<EndpointReference>): Promise<TestVaultResource> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, endpointReference };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting/withReferenceEndpoint',
@@ -27413,8 +27682,8 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withReferenceEndpointInternal(endpointReference));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._withReferenceEndpointInternal(endpointReference), this._client);
     }
 
     /** @internal */
@@ -27445,7 +27714,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
         const isProxied = options?.isProxied;
         const isExternal = options?.isExternal;
         const protocol = options?.protocol;
-        return new TestVaultResourcePromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol));
+        return new TestVaultResourcePromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol), this._client);
     }
 
     /** @internal */
@@ -27470,7 +27739,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new TestVaultResourcePromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied));
+        return new TestVaultResourcePromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -27495,7 +27764,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new TestVaultResourcePromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied));
+        return new TestVaultResourcePromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -27510,7 +27779,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withExternalHttpEndpointsInternal());
+        return new TestVaultResourcePromiseImpl(this._withExternalHttpEndpointsInternal(), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -27534,7 +27803,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._asHttp2ServiceInternal());
+        return new TestVaultResourcePromiseImpl(this._asHttp2ServiceInternal(), this._client);
     }
 
     /** @internal */
@@ -27554,7 +27823,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withUrlsCallbackInternal(callback));
+        return new TestVaultResourcePromiseImpl(this._withUrlsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -27571,7 +27840,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): TestVaultResourcePromise {
         const displayText = options?.displayText;
-        return new TestVaultResourcePromiseImpl(this._withUrlInternal(url, displayText));
+        return new TestVaultResourcePromiseImpl(this._withUrlInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -27588,7 +27857,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): TestVaultResourcePromise {
         const displayText = options?.displayText;
-        return new TestVaultResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText));
+        return new TestVaultResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -27607,7 +27876,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback));
+        return new TestVaultResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -27627,7 +27896,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback));
+        return new TestVaultResourcePromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -27642,11 +27911,12 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._excludeFromManifestInternal());
+        return new TestVaultResourcePromiseImpl(this._excludeFromManifestInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestVaultResource> {
+    private async _waitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestVaultResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting/waitForResource',
@@ -27656,12 +27926,13 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._waitForInternal(dependency));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._waitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<TestVaultResource> {
+    private async _waitForWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<TestVaultResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting/waitForWithBehavior',
@@ -27671,12 +27942,13 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
-    private async _waitForStartInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestVaultResource> {
+    private async _waitForStartInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestVaultResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting/waitForResourceStart',
@@ -27686,12 +27958,13 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._waitForStartInternal(dependency));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._waitForStartInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForStartWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<TestVaultResource> {
+    private async _waitForStartWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<TestVaultResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting/waitForStartWithBehavior',
@@ -27701,8 +27974,8 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
@@ -27717,11 +27990,12 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withExplicitStartInternal());
+        return new TestVaultResourcePromiseImpl(this._withExplicitStartInternal(), this._client);
     }
 
     /** @internal */
-    private async _waitForCompletionInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, exitCode?: number): Promise<TestVaultResource> {
+    private async _waitForCompletionInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, exitCode?: number): Promise<TestVaultResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         if (exitCode !== undefined) rpcArgs.exitCode = exitCode;
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
@@ -27732,9 +28006,9 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): TestVaultResourcePromise {
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): TestVaultResourcePromise {
         const exitCode = options?.exitCode;
-        return new TestVaultResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode));
+        return new TestVaultResourcePromiseImpl(this._waitForCompletionInternal(dependency, exitCode), this._client);
     }
 
     /** @internal */
@@ -27749,7 +28023,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Adds a health check by key */
     withHealthCheck(key: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withHealthCheckInternal(key));
+        return new TestVaultResourcePromiseImpl(this._withHealthCheckInternal(key), this._client);
     }
 
     /** @internal */
@@ -27770,7 +28044,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
         const path = options?.path;
         const statusCode = options?.statusCode;
         const endpointName = options?.endpointName;
-        return new TestVaultResourcePromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName));
+        return new TestVaultResourcePromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName), this._client);
     }
 
     /** @internal */
@@ -27792,7 +28066,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): TestVaultResourcePromise {
         const commandOptions = options?.commandOptions;
-        return new TestVaultResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions));
+        return new TestVaultResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions), this._client);
     }
 
     /** @internal */
@@ -27807,7 +28081,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withDeveloperCertificateTrustInternal(trust));
+        return new TestVaultResourcePromiseImpl(this._withDeveloperCertificateTrustInternal(trust), this._client);
     }
 
     /** @internal */
@@ -27822,11 +28096,12 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withCertificateTrustScopeInternal(scope));
+        return new TestVaultResourcePromiseImpl(this._withCertificateTrustScopeInternal(scope), this._client);
     }
 
     /** @internal */
-    private async _withHttpsDeveloperCertificateInternal(password?: ParameterResource): Promise<TestVaultResource> {
+    private async _withHttpsDeveloperCertificateInternal(password?: Awaitable<ParameterResource>): Promise<TestVaultResource> {
+        password = isPromiseLike(password) ? await password : password;
         const rpcArgs: Record<string, unknown> = { builder: this._handle };
         if (password !== undefined) rpcArgs.password = password;
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
@@ -27838,8 +28113,8 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): TestVaultResourcePromise {
-        const password = options?.password;
-        return new TestVaultResourcePromiseImpl(this._withHttpsDeveloperCertificateInternal(password));
+        let password = options?.password;
+        return new TestVaultResourcePromiseImpl(this._withHttpsDeveloperCertificateInternal(password), this._client);
     }
 
     /** @internal */
@@ -27854,11 +28129,12 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withoutHttpsCertificateInternal());
+        return new TestVaultResourcePromiseImpl(this._withoutHttpsCertificateInternal(), this._client);
     }
 
     /** @internal */
-    private async _withParentRelationshipInternal(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestVaultResource> {
+    private async _withParentRelationshipInternal(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestVaultResource> {
+        parent = isPromiseLike(parent) ? await parent : parent;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, parent };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting/withBuilderParentRelationship',
@@ -27868,12 +28144,13 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withParentRelationshipInternal(parent));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._withParentRelationshipInternal(parent), this._client);
     }
 
     /** @internal */
-    private async _withChildRelationshipInternal(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestVaultResource> {
+    private async _withChildRelationshipInternal(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestVaultResource> {
+        child = isPromiseLike(child) ? await child : child;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, child };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting/withBuilderChildRelationship',
@@ -27883,8 +28160,8 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withChildRelationshipInternal(child));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._withChildRelationshipInternal(child), this._client);
     }
 
     /** @internal */
@@ -27901,7 +28178,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): TestVaultResourcePromise {
         const iconVariant = options?.iconVariant;
-        return new TestVaultResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant));
+        return new TestVaultResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant), this._client);
     }
 
     /** @internal */
@@ -27930,7 +28207,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
         const failureThreshold = options?.failureThreshold;
         const successThreshold = options?.successThreshold;
         const endpointName = options?.endpointName;
-        return new TestVaultResourcePromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName));
+        return new TestVaultResourcePromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName), this._client);
     }
 
     /** @internal */
@@ -27945,7 +28222,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._excludeFromMcpInternal());
+        return new TestVaultResourcePromiseImpl(this._excludeFromMcpInternal(), this._client);
     }
 
     /** @internal */
@@ -27960,7 +28237,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName));
+        return new TestVaultResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName), this._client);
     }
 
     /** @internal */
@@ -27975,7 +28252,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag));
+        return new TestVaultResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag), this._client);
     }
 
     /** @internal */
@@ -28003,7 +28280,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
         const requiredBy = options?.requiredBy;
         const tags = options?.tags;
         const description = options?.description;
-        return new TestVaultResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description));
+        return new TestVaultResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description), this._client);
     }
 
     /** @internal */
@@ -28023,7 +28300,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withPipelineConfigurationInternal(callback));
+        return new TestVaultResourcePromiseImpl(this._withPipelineConfigurationInternal(callback), this._client);
     }
 
     /** @internal */
@@ -28042,7 +28319,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     withVolume(target: string, options?: WithVolumeOptions): TestVaultResourcePromise {
         const name = options?.name;
         const isReadOnly = options?.isReadOnly;
-        return new TestVaultResourcePromiseImpl(this._withVolumeInternal(target, name, isReadOnly));
+        return new TestVaultResourcePromiseImpl(this._withVolumeInternal(target, name, isReadOnly), this._client);
     }
 
     /** Gets the resource name */
@@ -28071,7 +28348,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback));
+        return new TestVaultResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -28091,7 +28368,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._onResourceStoppedInternal(callback));
+        return new TestVaultResourcePromiseImpl(this._onResourceStoppedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -28111,7 +28388,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._onInitializeResourceInternal(callback));
+        return new TestVaultResourcePromiseImpl(this._onInitializeResourceInternal(callback), this._client);
     }
 
     /** @internal */
@@ -28131,7 +28408,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._onResourceEndpointsAllocatedInternal(callback));
+        return new TestVaultResourcePromiseImpl(this._onResourceEndpointsAllocatedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -28151,7 +28428,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._onResourceReadyInternal(callback));
+        return new TestVaultResourcePromiseImpl(this._onResourceReadyInternal(callback), this._client);
     }
 
     /** @internal */
@@ -28170,7 +28447,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     withOptionalString(options?: WithOptionalStringOptions): TestVaultResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new TestVaultResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new TestVaultResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -28185,7 +28462,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withConfigInternal(config));
+        return new TestVaultResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -28205,7 +28482,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback));
+        return new TestVaultResourcePromiseImpl(this._testWithEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -28220,7 +28497,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new TestVaultResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -28235,7 +28512,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new TestVaultResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -28250,7 +28527,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new TestVaultResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -28272,7 +28549,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): TestVaultResourcePromise {
         const callback = options?.callback;
-        return new TestVaultResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new TestVaultResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -28287,7 +28564,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withStatusInternal(status));
+        return new TestVaultResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -28302,7 +28579,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new TestVaultResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -28322,11 +28599,12 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new TestVaultResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<TestVaultResource> {
+    private async _testWaitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<TestVaultResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -28336,12 +28614,13 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<TestVaultResource> {
+    private async _withDependencyInternal(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<TestVaultResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -28351,12 +28630,13 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<TestVaultResource> {
+    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<TestVaultResource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<TestVaultResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -28366,8 +28646,8 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -28382,7 +28662,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new TestVaultResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -28397,7 +28677,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables));
+        return new TestVaultResourcePromiseImpl(this._withEnvironmentVariablesInternal(variables), this._client);
     }
 
     /** @internal */
@@ -28416,7 +28696,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new TestVaultResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** @internal */
@@ -28431,7 +28711,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures vault using direct interface target */
     withVaultDirect(option: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withVaultDirectInternal(option));
+        return new TestVaultResourcePromiseImpl(this._withVaultDirectInternal(option), this._client);
     }
 
     /** @internal */
@@ -28446,7 +28726,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new TestVaultResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -28461,7 +28741,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new TestVaultResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -28476,7 +28756,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new TestVaultResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -28491,7 +28771,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new TestVaultResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -28510,7 +28790,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): TestVaultResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new TestVaultResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new TestVaultResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -28529,7 +28809,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): TestVaultResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new TestVaultResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new TestVaultResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -28544,7 +28824,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new TestVaultResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -28559,7 +28839,7 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new TestVaultResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -28570,7 +28850,9 @@ class TestVaultResourceImpl extends ResourceBuilderBase<TestVaultResourceHandle>
  * await builder.addSomething().withX().withY();
  */
 class TestVaultResourcePromiseImpl implements TestVaultResourcePromise {
-    constructor(private _promise: Promise<TestVaultResource>) {}
+    constructor(private _promise: Promise<TestVaultResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = TestVaultResource, TResult2 = never>(
         onfulfilled?: ((value: TestVaultResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -28580,123 +28862,123 @@ class TestVaultResourcePromiseImpl implements TestVaultResourcePromise {
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)), this._client);
     }
 
     /** Adds a bind mount */
     withBindMount(source: string, target: string, options?: WithBindMountOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withBindMount(source, target, options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withBindMount(source, target, options)), this._client);
     }
 
     /** Sets the container entrypoint */
     withEntrypoint(entrypoint: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEntrypoint(entrypoint)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEntrypoint(entrypoint)), this._client);
     }
 
     /** Sets the container image tag */
     withImageTag(tag: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withImageTag(tag)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withImageTag(tag)), this._client);
     }
 
     /** Sets the container image registry */
     withImageRegistry(registry: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withImageRegistry(registry)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withImageRegistry(registry)), this._client);
     }
 
     /** Sets the container image */
     withImage(image: string, options?: WithImageOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withImage(image, options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withImage(image, options)), this._client);
     }
 
     /** Sets the image SHA256 digest */
     withImageSHA256(sha256: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withImageSHA256(sha256)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withImageSHA256(sha256)), this._client);
     }
 
     /** Adds runtime arguments for the container */
     withContainerRuntimeArgs(args: string[]): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withContainerRuntimeArgs(args)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withContainerRuntimeArgs(args)), this._client);
     }
 
     /** Sets the lifetime behavior of the container resource */
     withLifetime(lifetime: ContainerLifetime): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withLifetime(lifetime)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withLifetime(lifetime)), this._client);
     }
 
     /** Sets the container image pull policy */
     withImagePullPolicy(pullPolicy: ImagePullPolicy): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withImagePullPolicy(pullPolicy)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withImagePullPolicy(pullPolicy)), this._client);
     }
 
     /** Configures the resource to be published as a container */
     publishAsContainer(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.publishAsContainer()));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.publishAsContainer()), this._client);
     }
 
     /** Configures the resource to use a Dockerfile */
     withDockerfile(contextPath: string, options?: WithDockerfileOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withDockerfile(contextPath, options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withDockerfile(contextPath, options)), this._client);
     }
 
     /** Sets the container name */
     withContainerName(name: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withContainerName(name)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withContainerName(name)), this._client);
     }
 
     /** Adds a build argument from a parameter resource */
-    withBuildArg(name: string, value: ParameterResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withBuildArg(name, value)));
+    withBuildArg(name: string, value: Awaitable<ParameterResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withBuildArg(name, value)), this._client);
     }
 
     /** Adds a build secret from a parameter resource */
-    withBuildSecret(name: string, value: ParameterResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withBuildSecret(name, value)));
+    withBuildSecret(name: string, value: Awaitable<ParameterResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withBuildSecret(name, value)), this._client);
     }
 
     /** Configures endpoint proxy support */
     withEndpointProxySupport(proxyEnabled: boolean): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEndpointProxySupport(proxyEnabled)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEndpointProxySupport(proxyEnabled)), this._client);
     }
 
     /** Sets the base image for a Dockerfile build */
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)), this._client);
     }
 
     /** Adds a network alias for the container */
     withContainerNetworkAlias(alias: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withContainerNetworkAlias(alias)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withContainerNetworkAlias(alias)), this._client);
     }
 
     /** Configures an MCP server endpoint on the resource */
     withMcpServer(options?: WithMcpServerOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMcpServer(options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMcpServer(options)), this._client);
     }
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporter()));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporter()), this._client);
     }
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)), this._client);
     }
 
     /** Publishes the resource as a connection string */
     publishAsConnectionString(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.publishAsConnectionString()));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.publishAsConnectionString()), this._client);
     }
 
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)), this._client);
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)), this._client);
     }
 
     /**
@@ -28704,86 +28986,86 @@ class TestVaultResourcePromiseImpl implements TestVaultResourcePromise {
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)), this._client);
     }
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)), this._client);
     }
 
     /**
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)), this._client);
     }
 
     /**
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)), this._client);
     }
 
     /**
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)), this._client);
     }
 
     /** Adds arguments */
     withArgs(args: string[]): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withArgs(args)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withArgs(args)), this._client);
     }
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)), this._client);
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withReference(source, options)));
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withReference(source, options)), this._client);
     }
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)), this._client);
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)), this._client);
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)), this._client);
     }
 
     /** Adds a network endpoint */
     withEndpoint(options?: WithEndpointOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEndpoint(options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEndpoint(options)), this._client);
     }
 
     /** Adds an HTTP endpoint */
     withHttpEndpoint(options?: WithHttpEndpointOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)), this._client);
     }
 
     /** Adds an HTTPS endpoint */
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)), this._client);
     }
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -28793,152 +29075,152 @@ class TestVaultResourcePromiseImpl implements TestVaultResourcePromise {
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.asHttp2Service()));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.asHttp2Service()), this._client);
     }
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)), this._client);
     }
 
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)), this._client);
     }
 
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)), this._client);
     }
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)), this._client);
     }
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)), this._client);
     }
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()), this._client);
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.waitFor(dependency)), this._client);
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)), this._client);
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()), this._client);
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)));
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)), this._client);
     }
 
     /** Adds a health check by key */
     withHealthCheck(key: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)), this._client);
     }
 
     /** Adds an HTTP health check */
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)), this._client);
     }
 
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)), this._client);
     }
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)), this._client);
     }
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)), this._client);
     }
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)), this._client);
     }
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()), this._client);
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)), this._client);
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)), this._client);
     }
 
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)), this._client);
     }
 
     /** Adds an HTTP health probe to the resource */
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)), this._client);
     }
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()), this._client);
     }
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)), this._client);
     }
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)), this._client);
     }
 
     /** Adds a pipeline step to the resource */
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)), this._client);
     }
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)), this._client);
     }
 
     /** Adds a volume */
     withVolume(target: string, options?: WithVolumeOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withVolume(target, options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withVolume(target, options)), this._client);
     }
 
     /** Gets the resource name */
@@ -28948,152 +29230,152 @@ class TestVaultResourcePromiseImpl implements TestVaultResourcePromise {
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)), this._client);
     }
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)), this._client);
     }
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)), this._client);
     }
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)), this._client);
     }
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)), this._client);
     }
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): TestVaultResourcePromise {
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)), this._client);
     }
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Configures vault using direct interface target */
     withVaultDirect(option: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withVaultDirect(option)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withVaultDirect(option)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): TestVaultResourcePromise {
-        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new TestVaultResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -29134,7 +29416,7 @@ class ComputeResourceImpl extends ResourceBuilderBase<IComputeResourceHandle> im
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): ComputeResourcePromise {
-        return new ComputeResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName));
+        return new ComputeResourcePromiseImpl(this._withRemoteImageNameInternal(remoteImageName), this._client);
     }
 
     /** @internal */
@@ -29149,7 +29431,7 @@ class ComputeResourceImpl extends ResourceBuilderBase<IComputeResourceHandle> im
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): ComputeResourcePromise {
-        return new ComputeResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag));
+        return new ComputeResourcePromiseImpl(this._withRemoteImageTagInternal(remoteImageTag), this._client);
     }
 
 }
@@ -29160,7 +29442,9 @@ class ComputeResourceImpl extends ResourceBuilderBase<IComputeResourceHandle> im
  * await builder.addSomething().withX().withY();
  */
 class ComputeResourcePromiseImpl implements ComputeResourcePromise {
-    constructor(private _promise: Promise<ComputeResource>) {}
+    constructor(private _promise: Promise<ComputeResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ComputeResource, TResult2 = never>(
         onfulfilled?: ((value: ComputeResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -29171,12 +29455,12 @@ class ComputeResourcePromiseImpl implements ComputeResourcePromise {
 
     /** Sets the remote image name for publishing */
     withRemoteImageName(remoteImageName: string): ComputeResourcePromise {
-        return new ComputeResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)));
+        return new ComputeResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageName(remoteImageName)), this._client);
     }
 
     /** Sets the remote image tag for publishing */
     withRemoteImageTag(remoteImageTag: string): ComputeResourcePromise {
-        return new ComputeResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)));
+        return new ComputeResourcePromiseImpl(this._promise.then(obj => obj.withRemoteImageTag(remoteImageTag)), this._client);
     }
 
 }
@@ -29187,11 +29471,11 @@ class ComputeResourcePromiseImpl implements ComputeResourcePromise {
 
 export interface ContainerFilesDestinationResource {
     toJSON(): MarshalledHandle;
-    publishWithContainerFiles(source: ResourceWithContainerFiles, destinationPath: string): ContainerFilesDestinationResourcePromise;
+    publishWithContainerFiles(source: Awaitable<ResourceWithContainerFiles>, destinationPath: string): ContainerFilesDestinationResourcePromise;
 }
 
 export interface ContainerFilesDestinationResourcePromise extends PromiseLike<ContainerFilesDestinationResource> {
-    publishWithContainerFiles(source: ResourceWithContainerFiles, destinationPath: string): ContainerFilesDestinationResourcePromise;
+    publishWithContainerFiles(source: Awaitable<ResourceWithContainerFiles>, destinationPath: string): ContainerFilesDestinationResourcePromise;
 }
 
 // ============================================================================
@@ -29204,7 +29488,8 @@ class ContainerFilesDestinationResourceImpl extends ResourceBuilderBase<IContain
     }
 
     /** @internal */
-    private async _publishWithContainerFilesInternal(source: ResourceWithContainerFiles, destinationPath: string): Promise<ContainerFilesDestinationResource> {
+    private async _publishWithContainerFilesInternal(source: Awaitable<ResourceWithContainerFiles>, destinationPath: string): Promise<ContainerFilesDestinationResource> {
+        source = isPromiseLike(source) ? await source : source;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, source, destinationPath };
         const result = await this._client.invokeCapability<IContainerFilesDestinationResourceHandle>(
             'Aspire.Hosting/publishWithContainerFilesFromResource',
@@ -29214,8 +29499,8 @@ class ContainerFilesDestinationResourceImpl extends ResourceBuilderBase<IContain
     }
 
     /** Configures the resource to copy container files from the specified source during publishing */
-    publishWithContainerFiles(source: ResourceWithContainerFiles, destinationPath: string): ContainerFilesDestinationResourcePromise {
-        return new ContainerFilesDestinationResourcePromiseImpl(this._publishWithContainerFilesInternal(source, destinationPath));
+    publishWithContainerFiles(source: Awaitable<ResourceWithContainerFiles>, destinationPath: string): ContainerFilesDestinationResourcePromise {
+        return new ContainerFilesDestinationResourcePromiseImpl(this._publishWithContainerFilesInternal(source, destinationPath), this._client);
     }
 
 }
@@ -29226,7 +29511,9 @@ class ContainerFilesDestinationResourceImpl extends ResourceBuilderBase<IContain
  * await builder.addSomething().withX().withY();
  */
 class ContainerFilesDestinationResourcePromiseImpl implements ContainerFilesDestinationResourcePromise {
-    constructor(private _promise: Promise<ContainerFilesDestinationResource>) {}
+    constructor(private _promise: Promise<ContainerFilesDestinationResource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ContainerFilesDestinationResource, TResult2 = never>(
         onfulfilled?: ((value: ContainerFilesDestinationResource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -29236,8 +29523,8 @@ class ContainerFilesDestinationResourcePromiseImpl implements ContainerFilesDest
     }
 
     /** Configures the resource to copy container files from the specified source during publishing */
-    publishWithContainerFiles(source: ResourceWithContainerFiles, destinationPath: string): ContainerFilesDestinationResourcePromise {
-        return new ContainerFilesDestinationResourcePromiseImpl(this._promise.then(obj => obj.publishWithContainerFiles(source, destinationPath)));
+    publishWithContainerFiles(source: Awaitable<ResourceWithContainerFiles>, destinationPath: string): ContainerFilesDestinationResourcePromise {
+        return new ContainerFilesDestinationResourcePromiseImpl(this._promise.then(obj => obj.publishWithContainerFiles(source, destinationPath)), this._client);
     }
 
 }
@@ -29248,7 +29535,7 @@ class ContainerFilesDestinationResourcePromiseImpl implements ContainerFilesDest
 
 export interface Resource {
     toJSON(): MarshalledHandle;
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ResourcePromise;
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ResourcePromise;
@@ -29259,8 +29546,8 @@ export interface Resource {
     withExplicitStart(): ResourcePromise;
     withHealthCheck(key: string): ResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): ResourcePromise;
     excludeFromMcp(): ResourcePromise;
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ResourcePromise;
@@ -29279,9 +29566,9 @@ export interface Resource {
     withStatus(status: TestResourceStatus): ResourcePromise;
     withNestedConfig(config: TestNestedDto): ResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ResourcePromise;
     withEndpoints(endpoints: string[]): ResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ResourcePromise;
     withMergeLabel(label: string): ResourcePromise;
@@ -29295,7 +29582,7 @@ export interface Resource {
 }
 
 export interface ResourcePromise extends PromiseLike<Resource> {
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise;
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise;
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ResourcePromise;
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ResourcePromise;
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ResourcePromise;
@@ -29306,8 +29593,8 @@ export interface ResourcePromise extends PromiseLike<Resource> {
     withExplicitStart(): ResourcePromise;
     withHealthCheck(key: string): ResourcePromise;
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ResourcePromise;
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise;
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise;
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise;
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise;
     withIconName(iconName: string, options?: WithIconNameOptions): ResourcePromise;
     excludeFromMcp(): ResourcePromise;
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ResourcePromise;
@@ -29326,9 +29613,9 @@ export interface ResourcePromise extends PromiseLike<Resource> {
     withStatus(status: TestResourceStatus): ResourcePromise;
     withNestedConfig(config: TestNestedDto): ResourcePromise;
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ResourcePromise;
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise;
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ResourcePromise;
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ResourcePromise;
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise;
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ResourcePromise;
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ResourcePromise;
     withEndpoints(endpoints: string[]): ResourcePromise;
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ResourcePromise;
     withMergeLabel(label: string): ResourcePromise;
@@ -29351,7 +29638,8 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     }
 
     /** @internal */
-    private async _withContainerRegistryInternal(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<Resource> {
+    private async _withContainerRegistryInternal(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<Resource> {
+        registry = isPromiseLike(registry) ? await registry : registry;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, registry };
         const result = await this._client.invokeCapability<IResourceHandle>(
             'Aspire.Hosting/withContainerRegistry',
@@ -29361,8 +29649,8 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._withContainerRegistryInternal(registry));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._withContainerRegistryInternal(registry), this._client);
     }
 
     /** @internal */
@@ -29381,7 +29669,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ResourcePromise {
         const buildImage = options?.buildImage;
         const runtimeImage = options?.runtimeImage;
-        return new ResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage));
+        return new ResourcePromiseImpl(this._withDockerfileBaseImageInternal(buildImage, runtimeImage), this._client);
     }
 
     /** @internal */
@@ -29398,7 +29686,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ResourcePromise {
         const helpLink = options?.helpLink;
-        return new ResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink));
+        return new ResourcePromiseImpl(this._withRequiredCommandInternal(command, helpLink), this._client);
     }
 
     /** @internal */
@@ -29418,7 +29706,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._withUrlsCallbackInternal(callback));
+        return new ResourcePromiseImpl(this._withUrlsCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -29435,7 +29723,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): ResourcePromise {
         const displayText = options?.displayText;
-        return new ResourcePromiseImpl(this._withUrlInternal(url, displayText));
+        return new ResourcePromiseImpl(this._withUrlInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -29452,7 +29740,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ResourcePromise {
         const displayText = options?.displayText;
-        return new ResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText));
+        return new ResourcePromiseImpl(this._withUrlExpressionInternal(url, displayText), this._client);
     }
 
     /** @internal */
@@ -29471,7 +29759,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback));
+        return new ResourcePromiseImpl(this._withUrlForEndpointInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -29486,7 +29774,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): ResourcePromise {
-        return new ResourcePromiseImpl(this._excludeFromManifestInternal());
+        return new ResourcePromiseImpl(this._excludeFromManifestInternal(), this._client);
     }
 
     /** @internal */
@@ -29501,7 +29789,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): ResourcePromise {
-        return new ResourcePromiseImpl(this._withExplicitStartInternal());
+        return new ResourcePromiseImpl(this._withExplicitStartInternal(), this._client);
     }
 
     /** @internal */
@@ -29516,7 +29804,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Adds a health check by key */
     withHealthCheck(key: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._withHealthCheckInternal(key));
+        return new ResourcePromiseImpl(this._withHealthCheckInternal(key), this._client);
     }
 
     /** @internal */
@@ -29538,11 +29826,12 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ResourcePromise {
         const commandOptions = options?.commandOptions;
-        return new ResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions));
+        return new ResourcePromiseImpl(this._withCommandInternal(name, displayName, executeCommand, commandOptions), this._client);
     }
 
     /** @internal */
-    private async _withParentRelationshipInternal(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<Resource> {
+    private async _withParentRelationshipInternal(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<Resource> {
+        parent = isPromiseLike(parent) ? await parent : parent;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, parent };
         const result = await this._client.invokeCapability<IResourceHandle>(
             'Aspire.Hosting/withBuilderParentRelationship',
@@ -29552,12 +29841,13 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._withParentRelationshipInternal(parent));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._withParentRelationshipInternal(parent), this._client);
     }
 
     /** @internal */
-    private async _withChildRelationshipInternal(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<Resource> {
+    private async _withChildRelationshipInternal(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<Resource> {
+        child = isPromiseLike(child) ? await child : child;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, child };
         const result = await this._client.invokeCapability<IResourceHandle>(
             'Aspire.Hosting/withBuilderChildRelationship',
@@ -29567,8 +29857,8 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._withChildRelationshipInternal(child));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._withChildRelationshipInternal(child), this._client);
     }
 
     /** @internal */
@@ -29585,7 +29875,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): ResourcePromise {
         const iconVariant = options?.iconVariant;
-        return new ResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant));
+        return new ResourcePromiseImpl(this._withIconNameInternal(iconName, iconVariant), this._client);
     }
 
     /** @internal */
@@ -29600,7 +29890,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): ResourcePromise {
-        return new ResourcePromiseImpl(this._excludeFromMcpInternal());
+        return new ResourcePromiseImpl(this._excludeFromMcpInternal(), this._client);
     }
 
     /** @internal */
@@ -29628,7 +29918,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
         const requiredBy = options?.requiredBy;
         const tags = options?.tags;
         const description = options?.description;
-        return new ResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description));
+        return new ResourcePromiseImpl(this._withPipelineStepFactoryInternal(stepName, callback, dependsOn, requiredBy, tags, description), this._client);
     }
 
     /** @internal */
@@ -29648,7 +29938,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._withPipelineConfigurationInternal(callback));
+        return new ResourcePromiseImpl(this._withPipelineConfigurationInternal(callback), this._client);
     }
 
     /** Gets the resource name */
@@ -29677,7 +29967,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback));
+        return new ResourcePromiseImpl(this._onBeforeResourceStartedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -29697,7 +29987,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._onResourceStoppedInternal(callback));
+        return new ResourcePromiseImpl(this._onResourceStoppedInternal(callback), this._client);
     }
 
     /** @internal */
@@ -29717,7 +30007,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._onInitializeResourceInternal(callback));
+        return new ResourcePromiseImpl(this._onInitializeResourceInternal(callback), this._client);
     }
 
     /** @internal */
@@ -29737,7 +30027,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._onResourceReadyInternal(callback));
+        return new ResourcePromiseImpl(this._onResourceReadyInternal(callback), this._client);
     }
 
     /** @internal */
@@ -29756,7 +30046,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     withOptionalString(options?: WithOptionalStringOptions): ResourcePromise {
         const value = options?.value;
         const enabled = options?.enabled;
-        return new ResourcePromiseImpl(this._withOptionalStringInternal(value, enabled));
+        return new ResourcePromiseImpl(this._withOptionalStringInternal(value, enabled), this._client);
     }
 
     /** @internal */
@@ -29771,7 +30061,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ResourcePromise {
-        return new ResourcePromiseImpl(this._withConfigInternal(config));
+        return new ResourcePromiseImpl(this._withConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -29786,7 +30076,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._withCreatedAtInternal(createdAt));
+        return new ResourcePromiseImpl(this._withCreatedAtInternal(createdAt), this._client);
     }
 
     /** @internal */
@@ -29801,7 +30091,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt));
+        return new ResourcePromiseImpl(this._withModifiedAtInternal(modifiedAt), this._client);
     }
 
     /** @internal */
@@ -29816,7 +30106,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._withCorrelationIdInternal(correlationId));
+        return new ResourcePromiseImpl(this._withCorrelationIdInternal(correlationId), this._client);
     }
 
     /** @internal */
@@ -29838,7 +30128,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ResourcePromise {
         const callback = options?.callback;
-        return new ResourcePromiseImpl(this._withOptionalCallbackInternal(callback));
+        return new ResourcePromiseImpl(this._withOptionalCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -29853,7 +30143,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ResourcePromise {
-        return new ResourcePromiseImpl(this._withStatusInternal(status));
+        return new ResourcePromiseImpl(this._withStatusInternal(status), this._client);
     }
 
     /** @internal */
@@ -29868,7 +30158,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ResourcePromise {
-        return new ResourcePromiseImpl(this._withNestedConfigInternal(config));
+        return new ResourcePromiseImpl(this._withNestedConfigInternal(config), this._client);
     }
 
     /** @internal */
@@ -29888,11 +30178,12 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ResourcePromise {
-        return new ResourcePromiseImpl(this._withValidatorInternal(validator));
+        return new ResourcePromiseImpl(this._withValidatorInternal(validator), this._client);
     }
 
     /** @internal */
-    private async _testWaitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<Resource> {
+    private async _testWaitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<Resource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<IResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/testWaitFor',
@@ -29902,12 +30193,13 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._testWaitForInternal(dependency));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._testWaitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withDependencyInternal(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<Resource> {
+    private async _withDependencyInternal(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<Resource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<IResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withDependency',
@@ -29917,12 +30209,13 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._withDependencyInternal(dependency));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._withDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<Resource> {
+    private async _withUnionDependencyInternal(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<Resource> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<IResourceHandle>(
             'Aspire.Hosting.CodeGeneration.TypeScript.Tests/withUnionDependency',
@@ -29932,8 +30225,8 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._withUnionDependencyInternal(dependency));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._withUnionDependencyInternal(dependency), this._client);
     }
 
     /** @internal */
@@ -29948,7 +30241,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ResourcePromise {
-        return new ResourcePromiseImpl(this._withEndpointsInternal(endpoints));
+        return new ResourcePromiseImpl(this._withEndpointsInternal(endpoints), this._client);
     }
 
     /** @internal */
@@ -29967,7 +30260,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._withCancellableOperationInternal(operation));
+        return new ResourcePromiseImpl(this._withCancellableOperationInternal(operation), this._client);
     }
 
     /** @internal */
@@ -29982,7 +30275,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._withMergeLabelInternal(label));
+        return new ResourcePromiseImpl(this._withMergeLabelInternal(label), this._client);
     }
 
     /** @internal */
@@ -29997,7 +30290,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category));
+        return new ResourcePromiseImpl(this._withMergeLabelCategorizedInternal(label, category), this._client);
     }
 
     /** @internal */
@@ -30012,7 +30305,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ResourcePromise {
-        return new ResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port));
+        return new ResourcePromiseImpl(this._withMergeEndpointInternal(endpointName, port), this._client);
     }
 
     /** @internal */
@@ -30027,7 +30320,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme));
+        return new ResourcePromiseImpl(this._withMergeEndpointSchemeInternal(endpointName, port, scheme), this._client);
     }
 
     /** @internal */
@@ -30046,7 +30339,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles));
+        return new ResourcePromiseImpl(this._withMergeLoggingInternal(logLevel, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -30065,7 +30358,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ResourcePromise {
         const enableConsole = options?.enableConsole;
         const maxFiles = options?.maxFiles;
-        return new ResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles));
+        return new ResourcePromiseImpl(this._withMergeLoggingPathInternal(logLevel, logPath, enableConsole, maxFiles), this._client);
     }
 
     /** @internal */
@@ -30080,7 +30373,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ResourcePromise {
-        return new ResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority));
+        return new ResourcePromiseImpl(this._withMergeRouteInternal(path, method, handler, priority), this._client);
     }
 
     /** @internal */
@@ -30095,7 +30388,7 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware));
+        return new ResourcePromiseImpl(this._withMergeRouteMiddlewareInternal(path, method, handler, priority, middleware), this._client);
     }
 
 }
@@ -30106,7 +30399,9 @@ class ResourceImpl extends ResourceBuilderBase<IResourceHandle> implements Resou
  * await builder.addSomething().withX().withY();
  */
 class ResourcePromiseImpl implements ResourcePromise {
-    constructor(private _promise: Promise<Resource>) {}
+    constructor(private _promise: Promise<Resource>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = Resource, TResult2 = never>(
         onfulfilled?: ((value: Resource) => TResult1 | PromiseLike<TResult1>) | null,
@@ -30116,88 +30411,88 @@ class ResourcePromiseImpl implements ResourcePromise {
     }
 
     /** Configures a resource to use a container registry */
-    withContainerRegistry(registry: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)));
+    withContainerRegistry(registry: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withContainerRegistry(registry)), this._client);
     }
 
     /** Sets the base image for a Dockerfile build */
     withDockerfileBaseImage(options?: WithDockerfileBaseImageOptions): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withDockerfileBaseImage(options)), this._client);
     }
 
     /** Adds a required command dependency */
     withRequiredCommand(command: string, options?: WithRequiredCommandOptions): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withRequiredCommand(command, options)), this._client);
     }
 
     /** Customizes displayed URLs via callback */
     withUrlsCallback(callback: (obj: ResourceUrlsCallbackContext) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withUrlsCallback(callback)), this._client);
     }
 
     /** Adds or modifies displayed URLs */
     withUrl(url: string, options?: WithUrlOptions): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withUrl(url, options)), this._client);
     }
 
     /** Adds a URL using a reference expression */
     withUrlExpression(url: ReferenceExpression, options?: WithUrlExpressionOptions): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withUrlExpression(url, options)), this._client);
     }
 
     /** Customizes the URL for a specific endpoint via callback */
     withUrlForEndpoint(endpointName: string, callback: (obj: ResourceUrlAnnotation) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withUrlForEndpoint(endpointName, callback)), this._client);
     }
 
     /** Excludes the resource from the deployment manifest */
     excludeFromManifest(): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.excludeFromManifest()), this._client);
     }
 
     /** Prevents resource from starting automatically */
     withExplicitStart(): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withExplicitStart()), this._client);
     }
 
     /** Adds a health check by key */
     withHealthCheck(key: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withHealthCheck(key)), this._client);
     }
 
     /** Adds a resource command */
     withCommand(name: string, displayName: string, executeCommand: (arg: ExecuteCommandContext) => Promise<ExecuteCommandResult>, options?: WithCommandOptions): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withCommand(name, displayName, executeCommand, options)), this._client);
     }
 
     /** Sets the parent relationship */
-    withParentRelationship(parent: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)));
+    withParentRelationship(parent: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withParentRelationship(parent)), this._client);
     }
 
     /** Sets a child relationship */
-    withChildRelationship(child: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)));
+    withChildRelationship(child: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withChildRelationship(child)), this._client);
     }
 
     /** Sets the icon for the resource */
     withIconName(iconName: string, options?: WithIconNameOptions): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withIconName(iconName, options)), this._client);
     }
 
     /** Excludes the resource from MCP server exposure */
     excludeFromMcp(): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.excludeFromMcp()), this._client);
     }
 
     /** Adds a pipeline step to the resource */
     withPipelineStepFactory(stepName: string, callback: (arg: PipelineStepContext) => Promise<void>, options?: WithPipelineStepFactoryOptions): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withPipelineStepFactory(stepName, callback, options)), this._client);
     }
 
     /** Configures pipeline step dependencies via a callback */
     withPipelineConfiguration(callback: (obj: PipelineConfigurationContext) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withPipelineConfiguration(callback)), this._client);
     }
 
     /** Gets the resource name */
@@ -30207,132 +30502,132 @@ class ResourcePromiseImpl implements ResourcePromise {
 
     /** Subscribes to the BeforeResourceStarted event */
     onBeforeResourceStarted(callback: (arg: BeforeResourceStartedEvent) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.onBeforeResourceStarted(callback)), this._client);
     }
 
     /** Subscribes to the ResourceStopped event */
     onResourceStopped(callback: (arg: ResourceStoppedEvent) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.onResourceStopped(callback)), this._client);
     }
 
     /** Subscribes to the InitializeResource event */
     onInitializeResource(callback: (arg: InitializeResourceEvent) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.onInitializeResource(callback)), this._client);
     }
 
     /** Subscribes to the ResourceReady event */
     onResourceReady(callback: (arg: ResourceReadyEvent) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.onResourceReady(callback)), this._client);
     }
 
     /** Adds an optional string parameter */
     withOptionalString(options?: WithOptionalStringOptions): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withOptionalString(options)), this._client);
     }
 
     /** Configures the resource with a DTO */
     withConfig(config: TestConfigDto): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withConfig(config)), this._client);
     }
 
     /** Sets the created timestamp */
     withCreatedAt(createdAt: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withCreatedAt(createdAt)), this._client);
     }
 
     /** Sets the modified timestamp */
     withModifiedAt(modifiedAt: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withModifiedAt(modifiedAt)), this._client);
     }
 
     /** Sets the correlation ID */
     withCorrelationId(correlationId: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withCorrelationId(correlationId)), this._client);
     }
 
     /** Configures with optional callback */
     withOptionalCallback(options?: WithOptionalCallbackOptions): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withOptionalCallback(options)), this._client);
     }
 
     /** Sets the resource status */
     withStatus(status: TestResourceStatus): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withStatus(status)), this._client);
     }
 
     /** Configures with nested DTO */
     withNestedConfig(config: TestNestedDto): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withNestedConfig(config)), this._client);
     }
 
     /** Adds validation callback */
     withValidator(validator: (arg: TestResourceContext) => Promise<boolean>): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withValidator(validator)), this._client);
     }
 
     /** Waits for another resource (test version) */
-    testWaitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)));
+    testWaitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.testWaitFor(dependency)), this._client);
     }
 
     /** Adds a dependency on another resource */
-    withDependency(dependency: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)));
+    withDependency(dependency: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withDependency(dependency)), this._client);
     }
 
     /** Adds a dependency from a string or another resource */
-    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)));
+    withUnionDependency(dependency: string | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ResourcePromise {
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withUnionDependency(dependency)), this._client);
     }
 
     /** Sets the endpoints */
     withEndpoints(endpoints: string[]): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withEndpoints(endpoints)), this._client);
     }
 
     /** Performs a cancellable operation */
     withCancellableOperation(operation: (arg: CancellationToken) => Promise<void>): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withCancellableOperation(operation)), this._client);
     }
 
     /** Adds a label to the resource */
     withMergeLabel(label: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabel(label)), this._client);
     }
 
     /** Adds a categorized label to the resource */
     withMergeLabelCategorized(label: string, category: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeLabelCategorized(label, category)), this._client);
     }
 
     /** Configures a named endpoint */
     withMergeEndpoint(endpointName: string, port: number): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpoint(endpointName, port)), this._client);
     }
 
     /** Configures a named endpoint with scheme */
     withMergeEndpointScheme(endpointName: string, port: number, scheme: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeEndpointScheme(endpointName, port, scheme)), this._client);
     }
 
     /** Configures resource logging */
     withMergeLogging(logLevel: string, options?: WithMergeLoggingOptions): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeLogging(logLevel, options)), this._client);
     }
 
     /** Configures resource logging with file path */
     withMergeLoggingPath(logLevel: string, logPath: string, options?: WithMergeLoggingPathOptions): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeLoggingPath(logLevel, logPath, options)), this._client);
     }
 
     /** Configures a route */
     withMergeRoute(path: string, method: string, handler: string, priority: number): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeRoute(path, method, handler, priority)), this._client);
     }
 
     /** Configures a route with middleware */
     withMergeRouteMiddleware(path: string, method: string, handler: string, priority: number, middleware: string): ResourcePromise {
-        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)));
+        return new ResourcePromiseImpl(this._promise.then(obj => obj.withMergeRouteMiddleware(path, method, handler, priority, middleware)), this._client);
     }
 
 }
@@ -30373,7 +30668,7 @@ class ResourceWithArgsImpl extends ResourceBuilderBase<IResourceWithArgsHandle>
 
     /** Adds arguments */
     withArgs(args: string[]): ResourceWithArgsPromise {
-        return new ResourceWithArgsPromiseImpl(this._withArgsInternal(args));
+        return new ResourceWithArgsPromiseImpl(this._withArgsInternal(args), this._client);
     }
 
     /** @internal */
@@ -30393,7 +30688,7 @@ class ResourceWithArgsImpl extends ResourceBuilderBase<IResourceWithArgsHandle>
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): ResourceWithArgsPromise {
-        return new ResourceWithArgsPromiseImpl(this._withArgsCallbackInternal(callback));
+        return new ResourceWithArgsPromiseImpl(this._withArgsCallbackInternal(callback), this._client);
     }
 
 }
@@ -30404,7 +30699,9 @@ class ResourceWithArgsImpl extends ResourceBuilderBase<IResourceWithArgsHandle>
  * await builder.addSomething().withX().withY();
  */
 class ResourceWithArgsPromiseImpl implements ResourceWithArgsPromise {
-    constructor(private _promise: Promise<ResourceWithArgs>) {}
+    constructor(private _promise: Promise<ResourceWithArgs>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ResourceWithArgs, TResult2 = never>(
         onfulfilled?: ((value: ResourceWithArgs) => TResult1 | PromiseLike<TResult1>) | null,
@@ -30415,12 +30712,12 @@ class ResourceWithArgsPromiseImpl implements ResourceWithArgsPromise {
 
     /** Adds arguments */
     withArgs(args: string[]): ResourceWithArgsPromise {
-        return new ResourceWithArgsPromiseImpl(this._promise.then(obj => obj.withArgs(args)));
+        return new ResourceWithArgsPromiseImpl(this._promise.then(obj => obj.withArgs(args)), this._client);
     }
 
     /** Sets command-line arguments via callback */
     withArgsCallback(callback: (obj: CommandLineArgsCallbackContext) => Promise<void>): ResourceWithArgsPromise {
-        return new ResourceWithArgsPromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)));
+        return new ResourceWithArgsPromiseImpl(this._promise.then(obj => obj.withArgsCallback(callback)), this._client);
     }
 
 }
@@ -30469,7 +30766,7 @@ class ResourceWithConnectionStringImpl extends ResourceBuilderBase<IResourceWith
 
     /** Adds a connection property with a reference expression */
     withConnectionProperty(name: string, value: ReferenceExpression): ResourceWithConnectionStringPromise {
-        return new ResourceWithConnectionStringPromiseImpl(this._withConnectionPropertyInternal(name, value));
+        return new ResourceWithConnectionStringPromiseImpl(this._withConnectionPropertyInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -30484,7 +30781,7 @@ class ResourceWithConnectionStringImpl extends ResourceBuilderBase<IResourceWith
 
     /** Adds a connection property with a string value */
     withConnectionPropertyValue(name: string, value: string): ResourceWithConnectionStringPromise {
-        return new ResourceWithConnectionStringPromiseImpl(this._withConnectionPropertyValueInternal(name, value));
+        return new ResourceWithConnectionStringPromiseImpl(this._withConnectionPropertyValueInternal(name, value), this._client);
     }
 
     /** Gets a connection property by key */
@@ -30513,7 +30810,7 @@ class ResourceWithConnectionStringImpl extends ResourceBuilderBase<IResourceWith
 
     /** Subscribes to the ConnectionStringAvailable event */
     onConnectionStringAvailable(callback: (arg: ConnectionStringAvailableEvent) => Promise<void>): ResourceWithConnectionStringPromise {
-        return new ResourceWithConnectionStringPromiseImpl(this._onConnectionStringAvailableInternal(callback));
+        return new ResourceWithConnectionStringPromiseImpl(this._onConnectionStringAvailableInternal(callback), this._client);
     }
 
     /** @internal */
@@ -30528,7 +30825,7 @@ class ResourceWithConnectionStringImpl extends ResourceBuilderBase<IResourceWith
 
     /** Sets the connection string using a reference expression */
     withConnectionString(connectionString: ReferenceExpression): ResourceWithConnectionStringPromise {
-        return new ResourceWithConnectionStringPromiseImpl(this._withConnectionStringInternal(connectionString));
+        return new ResourceWithConnectionStringPromiseImpl(this._withConnectionStringInternal(connectionString), this._client);
     }
 
     /** @internal */
@@ -30543,7 +30840,7 @@ class ResourceWithConnectionStringImpl extends ResourceBuilderBase<IResourceWith
 
     /** Sets connection string using direct interface target */
     withConnectionStringDirect(connectionString: string): ResourceWithConnectionStringPromise {
-        return new ResourceWithConnectionStringPromiseImpl(this._withConnectionStringDirectInternal(connectionString));
+        return new ResourceWithConnectionStringPromiseImpl(this._withConnectionStringDirectInternal(connectionString), this._client);
     }
 
 }
@@ -30554,7 +30851,9 @@ class ResourceWithConnectionStringImpl extends ResourceBuilderBase<IResourceWith
  * await builder.addSomething().withX().withY();
  */
 class ResourceWithConnectionStringPromiseImpl implements ResourceWithConnectionStringPromise {
-    constructor(private _promise: Promise<ResourceWithConnectionString>) {}
+    constructor(private _promise: Promise<ResourceWithConnectionString>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ResourceWithConnectionString, TResult2 = never>(
         onfulfilled?: ((value: ResourceWithConnectionString) => TResult1 | PromiseLike<TResult1>) | null,
@@ -30565,12 +30864,12 @@ class ResourceWithConnectionStringPromiseImpl implements ResourceWithConnectionS
 
     /** Adds a connection property with a reference expression */
     withConnectionProperty(name: string, value: ReferenceExpression): ResourceWithConnectionStringPromise {
-        return new ResourceWithConnectionStringPromiseImpl(this._promise.then(obj => obj.withConnectionProperty(name, value)));
+        return new ResourceWithConnectionStringPromiseImpl(this._promise.then(obj => obj.withConnectionProperty(name, value)), this._client);
     }
 
     /** Adds a connection property with a string value */
     withConnectionPropertyValue(name: string, value: string): ResourceWithConnectionStringPromise {
-        return new ResourceWithConnectionStringPromiseImpl(this._promise.then(obj => obj.withConnectionPropertyValue(name, value)));
+        return new ResourceWithConnectionStringPromiseImpl(this._promise.then(obj => obj.withConnectionPropertyValue(name, value)), this._client);
     }
 
     /** Gets a connection property by key */
@@ -30580,17 +30879,17 @@ class ResourceWithConnectionStringPromiseImpl implements ResourceWithConnectionS
 
     /** Subscribes to the ConnectionStringAvailable event */
     onConnectionStringAvailable(callback: (arg: ConnectionStringAvailableEvent) => Promise<void>): ResourceWithConnectionStringPromise {
-        return new ResourceWithConnectionStringPromiseImpl(this._promise.then(obj => obj.onConnectionStringAvailable(callback)));
+        return new ResourceWithConnectionStringPromiseImpl(this._promise.then(obj => obj.onConnectionStringAvailable(callback)), this._client);
     }
 
     /** Sets the connection string using a reference expression */
     withConnectionString(connectionString: ReferenceExpression): ResourceWithConnectionStringPromise {
-        return new ResourceWithConnectionStringPromiseImpl(this._promise.then(obj => obj.withConnectionString(connectionString)));
+        return new ResourceWithConnectionStringPromiseImpl(this._promise.then(obj => obj.withConnectionString(connectionString)), this._client);
     }
 
     /** Sets connection string using direct interface target */
     withConnectionStringDirect(connectionString: string): ResourceWithConnectionStringPromise {
-        return new ResourceWithConnectionStringPromiseImpl(this._promise.then(obj => obj.withConnectionStringDirect(connectionString)));
+        return new ResourceWithConnectionStringPromiseImpl(this._promise.then(obj => obj.withConnectionStringDirect(connectionString)), this._client);
     }
 
 }
@@ -30631,7 +30930,7 @@ class ResourceWithContainerFilesImpl extends ResourceBuilderBase<IResourceWithCo
 
     /** Sets the source directory for container files */
     withContainerFilesSource(sourcePath: string): ResourceWithContainerFilesPromise {
-        return new ResourceWithContainerFilesPromiseImpl(this._withContainerFilesSourceInternal(sourcePath));
+        return new ResourceWithContainerFilesPromiseImpl(this._withContainerFilesSourceInternal(sourcePath), this._client);
     }
 
     /** @internal */
@@ -30646,7 +30945,7 @@ class ResourceWithContainerFilesImpl extends ResourceBuilderBase<IResourceWithCo
 
     /** Clears all container file sources */
     clearContainerFilesSources(): ResourceWithContainerFilesPromise {
-        return new ResourceWithContainerFilesPromiseImpl(this._clearContainerFilesSourcesInternal());
+        return new ResourceWithContainerFilesPromiseImpl(this._clearContainerFilesSourcesInternal(), this._client);
     }
 
 }
@@ -30657,7 +30956,9 @@ class ResourceWithContainerFilesImpl extends ResourceBuilderBase<IResourceWithCo
  * await builder.addSomething().withX().withY();
  */
 class ResourceWithContainerFilesPromiseImpl implements ResourceWithContainerFilesPromise {
-    constructor(private _promise: Promise<ResourceWithContainerFiles>) {}
+    constructor(private _promise: Promise<ResourceWithContainerFiles>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ResourceWithContainerFiles, TResult2 = never>(
         onfulfilled?: ((value: ResourceWithContainerFiles) => TResult1 | PromiseLike<TResult1>) | null,
@@ -30668,12 +30969,12 @@ class ResourceWithContainerFilesPromiseImpl implements ResourceWithContainerFile
 
     /** Sets the source directory for container files */
     withContainerFilesSource(sourcePath: string): ResourceWithContainerFilesPromise {
-        return new ResourceWithContainerFilesPromiseImpl(this._promise.then(obj => obj.withContainerFilesSource(sourcePath)));
+        return new ResourceWithContainerFilesPromiseImpl(this._promise.then(obj => obj.withContainerFilesSource(sourcePath)), this._client);
     }
 
     /** Clears all container file sources */
     clearContainerFilesSources(): ResourceWithContainerFilesPromise {
-        return new ResourceWithContainerFilesPromiseImpl(this._promise.then(obj => obj.clearContainerFilesSources()));
+        return new ResourceWithContainerFilesPromiseImpl(this._promise.then(obj => obj.clearContainerFilesSources()), this._client);
     }
 
 }
@@ -30736,7 +31037,7 @@ class ResourceWithEndpointsImpl extends ResourceBuilderBase<IResourceWithEndpoin
     withMcpServer(options?: WithMcpServerOptions): ResourceWithEndpointsPromise {
         const path = options?.path;
         const endpointName = options?.endpointName;
-        return new ResourceWithEndpointsPromiseImpl(this._withMcpServerInternal(path, endpointName));
+        return new ResourceWithEndpointsPromiseImpl(this._withMcpServerInternal(path, endpointName), this._client);
     }
 
     /** @internal */
@@ -30767,7 +31068,7 @@ class ResourceWithEndpointsImpl extends ResourceBuilderBase<IResourceWithEndpoin
         const isProxied = options?.isProxied;
         const isExternal = options?.isExternal;
         const protocol = options?.protocol;
-        return new ResourceWithEndpointsPromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol));
+        return new ResourceWithEndpointsPromiseImpl(this._withEndpointInternal(port, targetPort, scheme, name, env, isProxied, isExternal, protocol), this._client);
     }
 
     /** @internal */
@@ -30792,7 +31093,7 @@ class ResourceWithEndpointsImpl extends ResourceBuilderBase<IResourceWithEndpoin
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new ResourceWithEndpointsPromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied));
+        return new ResourceWithEndpointsPromiseImpl(this._withHttpEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -30817,7 +31118,7 @@ class ResourceWithEndpointsImpl extends ResourceBuilderBase<IResourceWithEndpoin
         const name = options?.name;
         const env = options?.env;
         const isProxied = options?.isProxied;
-        return new ResourceWithEndpointsPromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied));
+        return new ResourceWithEndpointsPromiseImpl(this._withHttpsEndpointInternal(port, targetPort, name, env, isProxied), this._client);
     }
 
     /** @internal */
@@ -30832,7 +31133,7 @@ class ResourceWithEndpointsImpl extends ResourceBuilderBase<IResourceWithEndpoin
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): ResourceWithEndpointsPromise {
-        return new ResourceWithEndpointsPromiseImpl(this._withExternalHttpEndpointsInternal());
+        return new ResourceWithEndpointsPromiseImpl(this._withExternalHttpEndpointsInternal(), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -30856,7 +31157,7 @@ class ResourceWithEndpointsImpl extends ResourceBuilderBase<IResourceWithEndpoin
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): ResourceWithEndpointsPromise {
-        return new ResourceWithEndpointsPromiseImpl(this._asHttp2ServiceInternal());
+        return new ResourceWithEndpointsPromiseImpl(this._asHttp2ServiceInternal(), this._client);
     }
 
     /** @internal */
@@ -30876,7 +31177,7 @@ class ResourceWithEndpointsImpl extends ResourceBuilderBase<IResourceWithEndpoin
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): ResourceWithEndpointsPromise {
-        return new ResourceWithEndpointsPromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback));
+        return new ResourceWithEndpointsPromiseImpl(this._withUrlForEndpointFactoryInternal(endpointName, callback), this._client);
     }
 
     /** @internal */
@@ -30897,7 +31198,7 @@ class ResourceWithEndpointsImpl extends ResourceBuilderBase<IResourceWithEndpoin
         const path = options?.path;
         const statusCode = options?.statusCode;
         const endpointName = options?.endpointName;
-        return new ResourceWithEndpointsPromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName));
+        return new ResourceWithEndpointsPromiseImpl(this._withHttpHealthCheckInternal(path, statusCode, endpointName), this._client);
     }
 
     /** @internal */
@@ -30926,7 +31227,7 @@ class ResourceWithEndpointsImpl extends ResourceBuilderBase<IResourceWithEndpoin
         const failureThreshold = options?.failureThreshold;
         const successThreshold = options?.successThreshold;
         const endpointName = options?.endpointName;
-        return new ResourceWithEndpointsPromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName));
+        return new ResourceWithEndpointsPromiseImpl(this._withHttpProbeInternal(probeType, path, initialDelaySeconds, periodSeconds, timeoutSeconds, failureThreshold, successThreshold, endpointName), this._client);
     }
 
     /** @internal */
@@ -30946,7 +31247,7 @@ class ResourceWithEndpointsImpl extends ResourceBuilderBase<IResourceWithEndpoin
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): ResourceWithEndpointsPromise {
-        return new ResourceWithEndpointsPromiseImpl(this._onResourceEndpointsAllocatedInternal(callback));
+        return new ResourceWithEndpointsPromiseImpl(this._onResourceEndpointsAllocatedInternal(callback), this._client);
     }
 
 }
@@ -30957,7 +31258,9 @@ class ResourceWithEndpointsImpl extends ResourceBuilderBase<IResourceWithEndpoin
  * await builder.addSomething().withX().withY();
  */
 class ResourceWithEndpointsPromiseImpl implements ResourceWithEndpointsPromise {
-    constructor(private _promise: Promise<ResourceWithEndpoints>) {}
+    constructor(private _promise: Promise<ResourceWithEndpoints>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ResourceWithEndpoints, TResult2 = never>(
         onfulfilled?: ((value: ResourceWithEndpoints) => TResult1 | PromiseLike<TResult1>) | null,
@@ -30968,27 +31271,27 @@ class ResourceWithEndpointsPromiseImpl implements ResourceWithEndpointsPromise {
 
     /** Configures an MCP server endpoint on the resource */
     withMcpServer(options?: WithMcpServerOptions): ResourceWithEndpointsPromise {
-        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.withMcpServer(options)));
+        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.withMcpServer(options)), this._client);
     }
 
     /** Adds a network endpoint */
     withEndpoint(options?: WithEndpointOptions): ResourceWithEndpointsPromise {
-        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.withEndpoint(options)));
+        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.withEndpoint(options)), this._client);
     }
 
     /** Adds an HTTP endpoint */
     withHttpEndpoint(options?: WithHttpEndpointOptions): ResourceWithEndpointsPromise {
-        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)));
+        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.withHttpEndpoint(options)), this._client);
     }
 
     /** Adds an HTTPS endpoint */
     withHttpsEndpoint(options?: WithHttpsEndpointOptions): ResourceWithEndpointsPromise {
-        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)));
+        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.withHttpsEndpoint(options)), this._client);
     }
 
     /** Makes HTTP endpoints externally accessible */
     withExternalHttpEndpoints(): ResourceWithEndpointsPromise {
-        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()));
+        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.withExternalHttpEndpoints()), this._client);
     }
 
     /** Gets an endpoint reference */
@@ -30998,27 +31301,27 @@ class ResourceWithEndpointsPromiseImpl implements ResourceWithEndpointsPromise {
 
     /** Configures resource for HTTP/2 */
     asHttp2Service(): ResourceWithEndpointsPromise {
-        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.asHttp2Service()));
+        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.asHttp2Service()), this._client);
     }
 
     /** Adds a URL for a specific endpoint via factory callback */
     withUrlForEndpointFactory(endpointName: string, callback: (arg: EndpointReference) => Promise<ResourceUrlAnnotation>): ResourceWithEndpointsPromise {
-        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)));
+        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.withUrlForEndpointFactory(endpointName, callback)), this._client);
     }
 
     /** Adds an HTTP health check */
     withHttpHealthCheck(options?: WithHttpHealthCheckOptions): ResourceWithEndpointsPromise {
-        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)));
+        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.withHttpHealthCheck(options)), this._client);
     }
 
     /** Adds an HTTP health probe to the resource */
     withHttpProbe(probeType: ProbeType, options?: WithHttpProbeOptions): ResourceWithEndpointsPromise {
-        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)));
+        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.withHttpProbe(probeType, options)), this._client);
     }
 
     /** Subscribes to the ResourceEndpointsAllocated event */
     onResourceEndpointsAllocated(callback: (arg: ResourceEndpointsAllocatedEvent) => Promise<void>): ResourceWithEndpointsPromise {
-        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)));
+        return new ResourceWithEndpointsPromiseImpl(this._promise.then(obj => obj.onResourceEndpointsAllocated(callback)), this._client);
     }
 
 }
@@ -31031,16 +31334,16 @@ export interface ResourceWithEnvironment {
     toJSON(): MarshalledHandle;
     withOtlpExporter(): ResourceWithEnvironmentPromise;
     withOtlpExporterProtocol(protocol: OtlpProtocol): ResourceWithEnvironmentPromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): ResourceWithEnvironmentPromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): ResourceWithEnvironmentPromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): ResourceWithEnvironmentPromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): ResourceWithEnvironmentPromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): ResourceWithEnvironmentPromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): ResourceWithEnvironmentPromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ResourceWithEnvironmentPromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): ResourceWithEnvironmentPromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): ResourceWithEnvironmentPromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): ResourceWithEnvironmentPromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ResourceWithEnvironmentPromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): ResourceWithEnvironmentPromise;
     withReferenceUri(name: string, uri: string): ResourceWithEnvironmentPromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): ResourceWithEnvironmentPromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): ResourceWithEnvironmentPromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): ResourceWithEnvironmentPromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): ResourceWithEnvironmentPromise;
     withDeveloperCertificateTrust(trust: boolean): ResourceWithEnvironmentPromise;
     withCertificateTrustScope(scope: CertificateTrustScope): ResourceWithEnvironmentPromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): ResourceWithEnvironmentPromise;
@@ -31052,16 +31355,16 @@ export interface ResourceWithEnvironment {
 export interface ResourceWithEnvironmentPromise extends PromiseLike<ResourceWithEnvironment> {
     withOtlpExporter(): ResourceWithEnvironmentPromise;
     withOtlpExporterProtocol(protocol: OtlpProtocol): ResourceWithEnvironmentPromise;
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): ResourceWithEnvironmentPromise;
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): ResourceWithEnvironmentPromise;
     withEnvironmentExpression(name: string, value: ReferenceExpression): ResourceWithEnvironmentPromise;
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): ResourceWithEnvironmentPromise;
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): ResourceWithEnvironmentPromise;
-    withEnvironmentParameter(name: string, parameter: ParameterResource): ResourceWithEnvironmentPromise;
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ResourceWithEnvironmentPromise;
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): ResourceWithEnvironmentPromise;
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): ResourceWithEnvironmentPromise;
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): ResourceWithEnvironmentPromise;
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ResourceWithEnvironmentPromise;
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): ResourceWithEnvironmentPromise;
     withReferenceUri(name: string, uri: string): ResourceWithEnvironmentPromise;
-    withReferenceExternalService(externalService: ExternalServiceResource): ResourceWithEnvironmentPromise;
-    withReferenceEndpoint(endpointReference: EndpointReference): ResourceWithEnvironmentPromise;
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): ResourceWithEnvironmentPromise;
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): ResourceWithEnvironmentPromise;
     withDeveloperCertificateTrust(trust: boolean): ResourceWithEnvironmentPromise;
     withCertificateTrustScope(scope: CertificateTrustScope): ResourceWithEnvironmentPromise;
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): ResourceWithEnvironmentPromise;
@@ -31091,7 +31394,7 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._withOtlpExporterInternal());
+        return new ResourceWithEnvironmentPromiseImpl(this._withOtlpExporterInternal(), this._client);
     }
 
     /** @internal */
@@ -31106,11 +31409,12 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._withOtlpExporterProtocolInternal(protocol));
+        return new ResourceWithEnvironmentPromiseImpl(this._withOtlpExporterProtocolInternal(protocol), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): Promise<ResourceWithEnvironment> {
+    private async _withEnvironmentInternal(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): Promise<ResourceWithEnvironment> {
+        value = isPromiseLike(value) ? await value : value;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, value };
         const result = await this._client.invokeCapability<IResourceWithEnvironmentHandle>(
             'Aspire.Hosting/withEnvironment',
@@ -31120,8 +31424,8 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._withEnvironmentInternal(name, value));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): ResourceWithEnvironmentPromise {
+        return new ResourceWithEnvironmentPromiseImpl(this._withEnvironmentInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -31139,7 +31443,7 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._withEnvironmentExpressionInternal(name, value));
+        return new ResourceWithEnvironmentPromiseImpl(this._withEnvironmentExpressionInternal(name, value), this._client);
     }
 
     /** @internal */
@@ -31159,11 +31463,12 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._withEnvironmentCallbackInternal(callback));
+        return new ResourceWithEnvironmentPromiseImpl(this._withEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentEndpointInternal(name: string, endpointReference: EndpointReference): Promise<ResourceWithEnvironment> {
+    private async _withEnvironmentEndpointInternal(name: string, endpointReference: Awaitable<EndpointReference>): Promise<ResourceWithEnvironment> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, endpointReference };
         const result = await this._client.invokeCapability<IResourceWithEnvironmentHandle>(
             'Aspire.Hosting/withEnvironmentEndpoint',
@@ -31176,12 +31481,13 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): ResourceWithEnvironmentPromise {
+        return new ResourceWithEnvironmentPromiseImpl(this._withEnvironmentEndpointInternal(name, endpointReference), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentParameterInternal(name: string, parameter: ParameterResource): Promise<ResourceWithEnvironment> {
+    private async _withEnvironmentParameterInternal(name: string, parameter: Awaitable<ParameterResource>): Promise<ResourceWithEnvironment> {
+        parameter = isPromiseLike(parameter) ? await parameter : parameter;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, name, parameter };
         const result = await this._client.invokeCapability<IResourceWithEnvironmentHandle>(
             'Aspire.Hosting/withEnvironmentParameter',
@@ -31194,12 +31500,13 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._withEnvironmentParameterInternal(name, parameter));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): ResourceWithEnvironmentPromise {
+        return new ResourceWithEnvironmentPromiseImpl(this._withEnvironmentParameterInternal(name, parameter), this._client);
     }
 
     /** @internal */
-    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): Promise<ResourceWithEnvironment> {
+    private async _withEnvironmentConnectionStringInternal(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): Promise<ResourceWithEnvironment> {
+        resource = isPromiseLike(resource) ? await resource : resource;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, envVarName, resource };
         const result = await this._client.invokeCapability<IResourceWithEnvironmentHandle>(
             'Aspire.Hosting/withEnvironmentConnectionString',
@@ -31212,12 +31519,13 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ResourceWithEnvironmentPromise {
+        return new ResourceWithEnvironmentPromiseImpl(this._withEnvironmentConnectionStringInternal(envVarName, resource), this._client);
     }
 
     /** @internal */
-    private async _withReferenceInternal(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, connectionName?: string, optional?: boolean, name?: string): Promise<ResourceWithEnvironment> {
+    private async _withReferenceInternal(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, connectionName?: string, optional?: boolean, name?: string): Promise<ResourceWithEnvironment> {
+        source = isPromiseLike(source) ? await source : source;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, source };
         if (connectionName !== undefined) rpcArgs.connectionName = connectionName;
         if (optional !== undefined) rpcArgs.optional = optional;
@@ -31230,11 +31538,11 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): ResourceWithEnvironmentPromise {
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): ResourceWithEnvironmentPromise {
         const connectionName = options?.connectionName;
         const optional = options?.optional;
         const name = options?.name;
-        return new ResourceWithEnvironmentPromiseImpl(this._withReferenceInternal(source, connectionName, optional, name));
+        return new ResourceWithEnvironmentPromiseImpl(this._withReferenceInternal(source, connectionName, optional, name), this._client);
     }
 
     /** @internal */
@@ -31249,11 +31557,12 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._withReferenceUriInternal(name, uri));
+        return new ResourceWithEnvironmentPromiseImpl(this._withReferenceUriInternal(name, uri), this._client);
     }
 
     /** @internal */
-    private async _withReferenceExternalServiceInternal(externalService: ExternalServiceResource): Promise<ResourceWithEnvironment> {
+    private async _withReferenceExternalServiceInternal(externalService: Awaitable<ExternalServiceResource>): Promise<ResourceWithEnvironment> {
+        externalService = isPromiseLike(externalService) ? await externalService : externalService;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, externalService };
         const result = await this._client.invokeCapability<IResourceWithEnvironmentHandle>(
             'Aspire.Hosting/withReferenceExternalService',
@@ -31263,12 +31572,13 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._withReferenceExternalServiceInternal(externalService));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): ResourceWithEnvironmentPromise {
+        return new ResourceWithEnvironmentPromiseImpl(this._withReferenceExternalServiceInternal(externalService), this._client);
     }
 
     /** @internal */
-    private async _withReferenceEndpointInternal(endpointReference: EndpointReference): Promise<ResourceWithEnvironment> {
+    private async _withReferenceEndpointInternal(endpointReference: Awaitable<EndpointReference>): Promise<ResourceWithEnvironment> {
+        endpointReference = isPromiseLike(endpointReference) ? await endpointReference : endpointReference;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, endpointReference };
         const result = await this._client.invokeCapability<IResourceWithEnvironmentHandle>(
             'Aspire.Hosting/withReferenceEndpoint',
@@ -31278,8 +31588,8 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._withReferenceEndpointInternal(endpointReference));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): ResourceWithEnvironmentPromise {
+        return new ResourceWithEnvironmentPromiseImpl(this._withReferenceEndpointInternal(endpointReference), this._client);
     }
 
     /** @internal */
@@ -31294,7 +31604,7 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._withDeveloperCertificateTrustInternal(trust));
+        return new ResourceWithEnvironmentPromiseImpl(this._withDeveloperCertificateTrustInternal(trust), this._client);
     }
 
     /** @internal */
@@ -31309,11 +31619,12 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._withCertificateTrustScopeInternal(scope));
+        return new ResourceWithEnvironmentPromiseImpl(this._withCertificateTrustScopeInternal(scope), this._client);
     }
 
     /** @internal */
-    private async _withHttpsDeveloperCertificateInternal(password?: ParameterResource): Promise<ResourceWithEnvironment> {
+    private async _withHttpsDeveloperCertificateInternal(password?: Awaitable<ParameterResource>): Promise<ResourceWithEnvironment> {
+        password = isPromiseLike(password) ? await password : password;
         const rpcArgs: Record<string, unknown> = { builder: this._handle };
         if (password !== undefined) rpcArgs.password = password;
         const result = await this._client.invokeCapability<IResourceWithEnvironmentHandle>(
@@ -31325,8 +31636,8 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): ResourceWithEnvironmentPromise {
-        const password = options?.password;
-        return new ResourceWithEnvironmentPromiseImpl(this._withHttpsDeveloperCertificateInternal(password));
+        let password = options?.password;
+        return new ResourceWithEnvironmentPromiseImpl(this._withHttpsDeveloperCertificateInternal(password), this._client);
     }
 
     /** @internal */
@@ -31341,7 +31652,7 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._withoutHttpsCertificateInternal());
+        return new ResourceWithEnvironmentPromiseImpl(this._withoutHttpsCertificateInternal(), this._client);
     }
 
     /** @internal */
@@ -31361,7 +31672,7 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._testWithEnvironmentCallbackInternal(callback));
+        return new ResourceWithEnvironmentPromiseImpl(this._testWithEnvironmentCallbackInternal(callback), this._client);
     }
 
     /** @internal */
@@ -31376,7 +31687,7 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._withEnvironmentVariablesInternal(variables));
+        return new ResourceWithEnvironmentPromiseImpl(this._withEnvironmentVariablesInternal(variables), this._client);
     }
 
 }
@@ -31387,7 +31698,9 @@ class ResourceWithEnvironmentImpl extends ResourceBuilderBase<IResourceWithEnvir
  * await builder.addSomething().withX().withY();
  */
 class ResourceWithEnvironmentPromiseImpl implements ResourceWithEnvironmentPromise {
-    constructor(private _promise: Promise<ResourceWithEnvironment>) {}
+    constructor(private _promise: Promise<ResourceWithEnvironment>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ResourceWithEnvironment, TResult2 = never>(
         onfulfilled?: ((value: ResourceWithEnvironment) => TResult1 | PromiseLike<TResult1>) | null,
@@ -31398,17 +31711,17 @@ class ResourceWithEnvironmentPromiseImpl implements ResourceWithEnvironmentPromi
 
     /** Configures OTLP telemetry export */
     withOtlpExporter(): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withOtlpExporter()));
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withOtlpExporter()), this._client);
     }
 
     /** Configures OTLP telemetry export with specific protocol */
     withOtlpExporterProtocol(protocol: OtlpProtocol): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)));
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withOtlpExporterProtocol(protocol)), this._client);
     }
 
     /** Sets an environment variable */
-    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)));
+    withEnvironment(name: string, value: string | ReferenceExpression | EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression | Awaitable<EndpointReference | ParameterResource | ConnectionStringResource | ResourceWithConnectionString | TestRedisResource | EndpointReferenceExpression>): ResourceWithEnvironmentPromise {
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withEnvironment(name, value)), this._client);
     }
 
     /**
@@ -31416,86 +31729,86 @@ class ResourceWithEnvironmentPromiseImpl implements ResourceWithEnvironmentPromi
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
     withEnvironmentExpression(name: string, value: ReferenceExpression): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)));
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withEnvironmentExpression(name, value)), this._client);
     }
 
     /** Sets environment variables via callback */
     withEnvironmentCallback(callback: (arg: EnvironmentCallbackContext) => Promise<void>): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)));
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withEnvironmentCallback(callback)), this._client);
     }
 
     /**
      * Sets an environment variable from an endpoint reference
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentEndpoint(name: string, endpointReference: EndpointReference): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)));
+    withEnvironmentEndpoint(name: string, endpointReference: Awaitable<EndpointReference>): ResourceWithEnvironmentPromise {
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withEnvironmentEndpoint(name, endpointReference)), this._client);
     }
 
     /**
      * Sets an environment variable from a parameter resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentParameter(name: string, parameter: ParameterResource): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)));
+    withEnvironmentParameter(name: string, parameter: Awaitable<ParameterResource>): ResourceWithEnvironmentPromise {
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withEnvironmentParameter(name, parameter)), this._client);
     }
 
     /**
      * Sets an environment variable from a connection string resource
      * @deprecated ATS compatibility shim. Use withEnvironment instead.
      */
-    withEnvironmentConnectionString(envVarName: string, resource: ConnectionStringResource | ResourceWithConnectionString | TestRedisResource): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)));
+    withEnvironmentConnectionString(envVarName: string, resource: Awaitable<ConnectionStringResource | ResourceWithConnectionString | TestRedisResource>): ResourceWithEnvironmentPromise {
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withEnvironmentConnectionString(envVarName, resource)), this._client);
     }
 
     /** Adds a reference to another resource */
-    withReference(source: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WithReferenceOptions): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withReference(source, options)));
+    withReference(source: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WithReferenceOptions): ResourceWithEnvironmentPromise {
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withReference(source, options)), this._client);
     }
 
     /** Adds a reference to a URI */
     withReferenceUri(name: string, uri: string): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)));
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withReferenceUri(name, uri)), this._client);
     }
 
     /** Adds a reference to an external service */
-    withReferenceExternalService(externalService: ExternalServiceResource): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)));
+    withReferenceExternalService(externalService: Awaitable<ExternalServiceResource>): ResourceWithEnvironmentPromise {
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withReferenceExternalService(externalService)), this._client);
     }
 
     /** Adds a reference to an endpoint */
-    withReferenceEndpoint(endpointReference: EndpointReference): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)));
+    withReferenceEndpoint(endpointReference: Awaitable<EndpointReference>): ResourceWithEnvironmentPromise {
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withReferenceEndpoint(endpointReference)), this._client);
     }
 
     /** Configures developer certificate trust */
     withDeveloperCertificateTrust(trust: boolean): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)));
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withDeveloperCertificateTrust(trust)), this._client);
     }
 
     /** Sets the certificate trust scope */
     withCertificateTrustScope(scope: CertificateTrustScope): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)));
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withCertificateTrustScope(scope)), this._client);
     }
 
     /** Configures HTTPS with a developer certificate */
     withHttpsDeveloperCertificate(options?: WithHttpsDeveloperCertificateOptions): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)));
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withHttpsDeveloperCertificate(options)), this._client);
     }
 
     /** Removes HTTPS certificate configuration */
     withoutHttpsCertificate(): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()));
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withoutHttpsCertificate()), this._client);
     }
 
     /** Configures environment with callback (test version) */
     testWithEnvironmentCallback(callback: (arg: TestEnvironmentContext) => Promise<void>): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)));
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.testWithEnvironmentCallback(callback)), this._client);
     }
 
     /** Sets environment variables */
     withEnvironmentVariables(variables: Record<string, string>): ResourceWithEnvironmentPromise {
-        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)));
+        return new ResourceWithEnvironmentPromiseImpl(this._promise.then(obj => obj.withEnvironmentVariables(variables)), this._client);
     }
 
 }
@@ -31506,19 +31819,19 @@ class ResourceWithEnvironmentPromiseImpl implements ResourceWithEnvironmentPromi
 
 export interface ResourceWithWaitSupport {
     toJSON(): MarshalledHandle;
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourceWithWaitSupportPromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ResourceWithWaitSupportPromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourceWithWaitSupportPromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ResourceWithWaitSupportPromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ResourceWithWaitSupportPromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourceWithWaitSupportPromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ResourceWithWaitSupportPromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourceWithWaitSupportPromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ResourceWithWaitSupportPromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ResourceWithWaitSupportPromise;
 }
 
 export interface ResourceWithWaitSupportPromise extends PromiseLike<ResourceWithWaitSupport> {
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourceWithWaitSupportPromise;
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ResourceWithWaitSupportPromise;
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourceWithWaitSupportPromise;
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ResourceWithWaitSupportPromise;
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ResourceWithWaitSupportPromise;
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourceWithWaitSupportPromise;
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ResourceWithWaitSupportPromise;
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourceWithWaitSupportPromise;
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ResourceWithWaitSupportPromise;
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ResourceWithWaitSupportPromise;
 }
 
 // ============================================================================
@@ -31531,7 +31844,8 @@ class ResourceWithWaitSupportImpl extends ResourceBuilderBase<IResourceWithWaitS
     }
 
     /** @internal */
-    private async _waitForInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ResourceWithWaitSupport> {
+    private async _waitForInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ResourceWithWaitSupport> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<IResourceWithWaitSupportHandle>(
             'Aspire.Hosting/waitForResource',
@@ -31541,12 +31855,13 @@ class ResourceWithWaitSupportImpl extends ResourceBuilderBase<IResourceWithWaitS
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourceWithWaitSupportPromise {
-        return new ResourceWithWaitSupportPromiseImpl(this._waitForInternal(dependency));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourceWithWaitSupportPromise {
+        return new ResourceWithWaitSupportPromiseImpl(this._waitForInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<ResourceWithWaitSupport> {
+    private async _waitForWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<ResourceWithWaitSupport> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<IResourceWithWaitSupportHandle>(
             'Aspire.Hosting/waitForWithBehavior',
@@ -31556,12 +31871,13 @@ class ResourceWithWaitSupportImpl extends ResourceBuilderBase<IResourceWithWaitS
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ResourceWithWaitSupportPromise {
-        return new ResourceWithWaitSupportPromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ResourceWithWaitSupportPromise {
+        return new ResourceWithWaitSupportPromiseImpl(this._waitForWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
-    private async _waitForStartInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): Promise<ResourceWithWaitSupport> {
+    private async _waitForStartInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): Promise<ResourceWithWaitSupport> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         const result = await this._client.invokeCapability<IResourceWithWaitSupportHandle>(
             'Aspire.Hosting/waitForResourceStart',
@@ -31571,12 +31887,13 @@ class ResourceWithWaitSupportImpl extends ResourceBuilderBase<IResourceWithWaitS
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourceWithWaitSupportPromise {
-        return new ResourceWithWaitSupportPromiseImpl(this._waitForStartInternal(dependency));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourceWithWaitSupportPromise {
+        return new ResourceWithWaitSupportPromiseImpl(this._waitForStartInternal(dependency), this._client);
     }
 
     /** @internal */
-    private async _waitForStartWithBehaviorInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): Promise<ResourceWithWaitSupport> {
+    private async _waitForStartWithBehaviorInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): Promise<ResourceWithWaitSupport> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency, waitBehavior };
         const result = await this._client.invokeCapability<IResourceWithWaitSupportHandle>(
             'Aspire.Hosting/waitForStartWithBehavior',
@@ -31586,12 +31903,13 @@ class ResourceWithWaitSupportImpl extends ResourceBuilderBase<IResourceWithWaitS
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ResourceWithWaitSupportPromise {
-        return new ResourceWithWaitSupportPromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ResourceWithWaitSupportPromise {
+        return new ResourceWithWaitSupportPromiseImpl(this._waitForStartWithBehaviorInternal(dependency, waitBehavior), this._client);
     }
 
     /** @internal */
-    private async _waitForCompletionInternal(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, exitCode?: number): Promise<ResourceWithWaitSupport> {
+    private async _waitForCompletionInternal(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, exitCode?: number): Promise<ResourceWithWaitSupport> {
+        dependency = isPromiseLike(dependency) ? await dependency : dependency;
         const rpcArgs: Record<string, unknown> = { builder: this._handle, dependency };
         if (exitCode !== undefined) rpcArgs.exitCode = exitCode;
         const result = await this._client.invokeCapability<IResourceWithWaitSupportHandle>(
@@ -31602,9 +31920,9 @@ class ResourceWithWaitSupportImpl extends ResourceBuilderBase<IResourceWithWaitS
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ResourceWithWaitSupportPromise {
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ResourceWithWaitSupportPromise {
         const exitCode = options?.exitCode;
-        return new ResourceWithWaitSupportPromiseImpl(this._waitForCompletionInternal(dependency, exitCode));
+        return new ResourceWithWaitSupportPromiseImpl(this._waitForCompletionInternal(dependency, exitCode), this._client);
     }
 
 }
@@ -31615,7 +31933,9 @@ class ResourceWithWaitSupportImpl extends ResourceBuilderBase<IResourceWithWaitS
  * await builder.addSomething().withX().withY();
  */
 class ResourceWithWaitSupportPromiseImpl implements ResourceWithWaitSupportPromise {
-    constructor(private _promise: Promise<ResourceWithWaitSupport>) {}
+    constructor(private _promise: Promise<ResourceWithWaitSupport>, private _client: AspireClientRpc, track = true) {
+        if (track) { _client.trackPromise(_promise); }
+    }
 
     then<TResult1 = ResourceWithWaitSupport, TResult2 = never>(
         onfulfilled?: ((value: ResourceWithWaitSupport) => TResult1 | PromiseLike<TResult1>) | null,
@@ -31625,28 +31945,28 @@ class ResourceWithWaitSupportPromiseImpl implements ResourceWithWaitSupportPromi
     }
 
     /** Waits for another resource to be ready */
-    waitFor(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourceWithWaitSupportPromise {
-        return new ResourceWithWaitSupportPromiseImpl(this._promise.then(obj => obj.waitFor(dependency)));
+    waitFor(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourceWithWaitSupportPromise {
+        return new ResourceWithWaitSupportPromiseImpl(this._promise.then(obj => obj.waitFor(dependency)), this._client);
     }
 
     /** Waits for another resource with specific behavior */
-    waitForWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ResourceWithWaitSupportPromise {
-        return new ResourceWithWaitSupportPromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)));
+    waitForWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ResourceWithWaitSupportPromise {
+        return new ResourceWithWaitSupportPromiseImpl(this._promise.then(obj => obj.waitForWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Waits for another resource to start */
-    waitForStart(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource): ResourceWithWaitSupportPromise {
-        return new ResourceWithWaitSupportPromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)));
+    waitForStart(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>): ResourceWithWaitSupportPromise {
+        return new ResourceWithWaitSupportPromiseImpl(this._promise.then(obj => obj.waitForStart(dependency)), this._client);
     }
 
     /** Waits for another resource to start with specific behavior */
-    waitForStartWithBehavior(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, waitBehavior: WaitBehavior): ResourceWithWaitSupportPromise {
-        return new ResourceWithWaitSupportPromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)));
+    waitForStartWithBehavior(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, waitBehavior: WaitBehavior): ResourceWithWaitSupportPromise {
+        return new ResourceWithWaitSupportPromiseImpl(this._promise.then(obj => obj.waitForStartWithBehavior(dependency, waitBehavior)), this._client);
     }
 
     /** Waits for resource completion */
-    waitForCompletion(dependency: CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource, options?: WaitForCompletionOptions): ResourceWithWaitSupportPromise {
-        return new ResourceWithWaitSupportPromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)));
+    waitForCompletion(dependency: Awaitable<CSharpAppResource | ComputeResource | ConnectionStringResource | ContainerFilesDestinationResource | ContainerRegistryResource | ContainerResource | DotnetToolResource | ExecutableResource | ExternalServiceResource | ParameterResource | ProjectResource | Resource | ResourceWithArgs | ResourceWithConnectionString | ResourceWithContainerFiles | ResourceWithEndpoints | ResourceWithEnvironment | ResourceWithWaitSupport | TestDatabaseResource | TestRedisResource | TestVaultResource>, options?: WaitForCompletionOptions): ResourceWithWaitSupportPromise {
+        return new ResourceWithWaitSupportPromiseImpl(this._promise.then(obj => obj.waitForCompletion(dependency, options)), this._client);
     }
 
 }
@@ -31697,6 +32017,11 @@ export async function connect(): Promise<AspireClientRpc> {
 export async function createBuilder(options?: CreateBuilderOptions): Promise<DistributedApplicationBuilder> {
     const client = await connect();
 
+    // Apply client-side options before any tracking begins
+    if (options?.throwOnPendingRejections === false) {
+        client.throwOnPendingRejections = false;
+    }
+
     // Default args, projectDirectory, and appHostFilePath if not provided
     // ASPIRE_APPHOST_FILEPATH is set by the CLI for consistent socket hash computation
     const effectiveOptions: CreateBuilderOptions = {
@@ -31706,6 +32031,9 @@ export async function createBuilder(options?: CreateBuilderOptions): Promise<Dis
         appHostFilePath: options?.appHostFilePath ?? process.env.ASPIRE_APPHOST_FILEPATH
     };
 
+    // Strip client-only options before sending to the host
+    delete effectiveOptions.throwOnPendingRejections;
+
     const handle = await client.invokeCapability<IDistributedApplicationBuilderHandle>(
         'Aspire.Hosting/createBuilderWithOptions',
         { options: effectiveOptions }
@@ -31716,7 +32044,7 @@ export async function createBuilder(options?: CreateBuilderOptions): Promise<Dis
 // Re-export commonly used types
 export { Handle, AppHostUsageError, CancellationToken, CapabilityError, registerCallback } from './transport.js';
 export { refExpr, ReferenceExpression } from './base.js';
-export type { HandleReference } from './base.js';
+export type { HandleReference, Awaitable } from './base.js';
 
 // ============================================================================
 // Global Error Handling
diff --git a/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/Snapshots/base.verified.ts b/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/Snapshots/base.verified.ts
index 8d7033494fb..219eee04175 100644
--- a/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/Snapshots/base.verified.ts
+++ b/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/Snapshots/base.verified.ts
@@ -7,6 +7,12 @@ export { Handle, AspireClient, CapabilityError, CancellationToken, registerCallb
 export type { MarshalledHandle, AtsError, AtsErrorDetails, CallbackFunction } from './transport.js';
 export { AtsErrorCodes, isMarshalledHandle, isAtsError, wrapIfHandle } from './transport.js';
 
+/**
+ * Utility type for parameters that accept either a resolved value or a promise of that value.
+ * Used by generated APIs to allow passing un-awaited resource builders directly.
+ */
+export type Awaitable<T> = T | PromiseLike<T>;
+
 // ============================================================================
 // Reference Expression
 // ============================================================================
diff --git a/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/Snapshots/transport.verified.ts b/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/Snapshots/transport.verified.ts
index 9ebab0397fa..f78d951560b 100644
--- a/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/Snapshots/transport.verified.ts
+++ b/tests/Aspire.Hosting.CodeGeneration.TypeScript.Tests/Snapshots/transport.verified.ts
@@ -1,4 +1,4 @@
-// transport.ts - ATS transport layer: RPC, Handle, errors, callbacks
+// transport.ts - ATS transport layer: RPC, Handle, errors, callbacks
 import * as net from 'net';
 import * as rpc from 'vscode-jsonrpc/node.js';
 
@@ -14,6 +14,10 @@ export interface AspireClientRpc {
     readonly connected: boolean;
     invokeCapability<TResult = unknown>(capabilityId: string, args?: Record<string, unknown>): Promise<TResult>;
     cancelToken(cancellationId: string): Promise<boolean>;
+    trackPromise(promise: Promise<unknown>): void;
+    flushPendingPromises(): Promise<void>;
+    /** When true (default), rejected tracked promises are collected and re-thrown by flushPendingPromises. */
+    throwOnPendingRejections: boolean;
 }
 
 /**
@@ -385,7 +389,7 @@ export class AppHostUsageError extends Error {
     }
 }
 
-function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
+export function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
     return (
         value !== null &&
         (typeof value === 'object' || typeof value === 'function') &&
@@ -755,9 +759,57 @@ export class AspireClient implements AspireClientRpc {
     private _pendingCalls = 0;
     private _connectPromise: Promise<void> | null = null;
     private _disconnectNotified = false;
+    private _pendingPromises: Set<Promise<unknown>> = new Set();
+    private _rejectedErrors: Set<unknown> = new Set();
+    throwOnPendingRejections = true;
 
     constructor(private socketPath: string) { }
 
+    trackPromise(promise: Promise<unknown>): void {
+        this._pendingPromises.add(promise);
+        // Remove on both resolve and reject. The reject handler swallows the
+        // error to prevent Node.js unhandled-rejection crashes.
+        //
+        // When throwOnPendingRejections is true (default), rejection errors are
+        // eagerly collected so that flushPendingPromises can re-throw them even
+        // if the promise settles before flush is called.
+        //
+        // Limitation: JavaScript provides no way to detect whether a rejection
+        // was already observed by the caller (e.g., try { await p } catch {}).
+        // The .then() reject handler fires regardless. This means user-caught
+        // rejections will also be re-thrown by build(). We accept this tradeoff
+        // because the common case — an un-awaited chain fails silently — should
+        // fail loud. The uncommon case (catch an error from an un-awaited chain,
+        // then continue to build) can opt out with:
+        //   createBuilder({ throwOnPendingRejections: false })
+        promise.then(
+            () => this._pendingPromises.delete(promise),
+            (err) => {
+                this._pendingPromises.delete(promise);
+                if (this.throwOnPendingRejections) {
+                    this._rejectedErrors.add(err);
+                }
+            }
+        );
+    }
+
+    async flushPendingPromises(): Promise<void> {
+        if (this._pendingPromises.size > 0) {
+            console.warn(`Flushing ${this._pendingPromises.size} pending promise(s). Consider awaiting fluent calls to avoid implicit flushing.`);
+            // Snapshot the current set before awaiting. Promises tracked after
+            // flush starts (e.g. by .then() callbacks or the build PromiseImpl
+            // constructor) are excluded. This prevents deadlocks where a tracked
+            // promise depends on flush completing.
+            const pending = [...this._pendingPromises];
+            await Promise.allSettled(pending);
+        }
+        if (this._rejectedErrors.size > 0) {
+            const errors = [...this._rejectedErrors];
+            this._rejectedErrors.clear();
+            throw new AggregateError(errors, 'One or more unawaited fluent calls failed');
+        }
+    }
+
     /**
      * Register a callback to be called when the connection is lost
      */