diff --git a/src/Microsoft.DotNet.Interactive.Http.Parsing/Microsoft.DotNet.Interactive.Http.Parsing.csproj b/src/Microsoft.DotNet.Interactive.Http.Parsing/Microsoft.DotNet.Interactive.Http.Parsing.csproj
index 44079be844..f816cffa8c 100644
--- a/src/Microsoft.DotNet.Interactive.Http.Parsing/Microsoft.DotNet.Interactive.Http.Parsing.csproj
+++ b/src/Microsoft.DotNet.Interactive.Http.Parsing/Microsoft.DotNet.Interactive.Http.Parsing.csproj
@@ -19,6 +19,10 @@
     <NoWarn>$(NoWarn);NU5128</NoWarn>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Include="..\Microsoft.DotNet.Interactive\Utility\NullableAttributes.cs" Link="NullableAttributes.cs" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis" Version="$(MicrosoftCodeAnalysisCommonVersion)" />
   </ItemGroup>
diff --git a/src/Microsoft.DotNet.Interactive.Http/DateTimeUtilities.cs b/src/Microsoft.DotNet.Interactive.Http.Parsing/Parsing/DateTimeUtilities.cs
similarity index 100%
rename from src/Microsoft.DotNet.Interactive.Http/DateTimeUtilities.cs
rename to src/Microsoft.DotNet.Interactive.Http.Parsing/Parsing/DateTimeUtilities.cs
diff --git a/src/Microsoft.DotNet.Interactive.Http.Parsing/Parsing/DynamicExpressionUtilities.cs b/src/Microsoft.DotNet.Interactive.Http.Parsing/Parsing/DynamicExpressionUtilities.cs
new file mode 100644
index 0000000000..66bc36bc5f
--- /dev/null
+++ b/src/Microsoft.DotNet.Interactive.Http.Parsing/Parsing/DynamicExpressionUtilities.cs
@@ -0,0 +1,289 @@
+using Microsoft.DotNet.Interactive.Http;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.DotNet.Interactive.Http.Parsing
+{
+#nullable enable
+    internal static class DynamicExpressionUtilites
+    {
+
+        const string DateTime = "$datetime";
+        const string LocalDateTime = "$localDatetime";
+        const string OffsetRegex = """(?:\s+(?<offset>[-+]?[^\s]+)\s+(?<option>[^\s]+))?""";
+        const string TypeRegex = """(?:\s+(?<type>rfc1123|iso8601|'.+'|".+"))?""";
+
+        internal static Regex guidPattern = new Regex(@$"^\$guid$", RegexOptions.Compiled);
+        internal static Regex dateTimePattern = new Regex(@$"^\{DateTime}{TypeRegex}{OffsetRegex}$", RegexOptions.Compiled);
+        internal static Regex localDateTimePattern = new Regex(@$"^\{LocalDateTime}{TypeRegex}{OffsetRegex}$", RegexOptions.Compiled);
+        internal static Regex randomIntPattern = new Regex(@$"^\$randomInt(?:\s+(?<arguments>-?[^\s]+)){{0,2}}$", RegexOptions.Compiled);
+        internal static Regex timestampPattern = new Regex($@"^\$timestamp{OffsetRegex}$", RegexOptions.Compiled);
+
+        internal static HttpBindingResult<object?> ResolveExpressionBinding(HttpExpressionNode node, string expression)
+        {
+            var guidMatches = guidPattern.Matches(expression);
+            if (guidMatches.Count == 1)
+            {
+                return node.CreateBindingSuccess(Guid.NewGuid().ToString());
+            }
+
+            if (expression.Contains(DateTime))
+            {
+                var dateTimeMatches = dateTimePattern.Matches(expression);
+                if (dateTimeMatches.Count == 1)
+                {
+                    return GetDateTime(node, DateTime, expression, dateTimeMatches[0]);
+                }
+
+                return node.CreateBindingFailure(HttpDiagnostics.IncorrectDateTimeFormat(expression, DateTime));
+            }
+
+            if (expression.Contains(LocalDateTime))
+            {
+                var localDateTimeMatches = localDateTimePattern.Matches(expression);
+                if (localDateTimeMatches.Count == 1)
+                {
+                    return GetDateTime(node, LocalDateTime, expression, localDateTimeMatches[0]);
+                }
+
+                return node.CreateBindingFailure(HttpDiagnostics.IncorrectDateTimeFormat(expression, LocalDateTime));
+            }
+
+            if (expression.Contains("$timestamp"))
+            {
+                var timestampMatches = timestampPattern.Matches(expression);
+                if (timestampMatches.Count == 1)
+                {
+                    return GetTimestamp(node, expression, timestampMatches[0]);
+                }
+
+                return node.CreateBindingFailure(HttpDiagnostics.IncorrectTimestampFormat(expression));
+            }
+
+            if (expression.Contains("$randomInt"))
+            {
+                var randomIntMatches = randomIntPattern.Matches(expression);
+                if (randomIntMatches.Count == 1)
+                {
+                    return GetRandomInt(node, expression, randomIntMatches[0]);
+                }
+
+                return node.CreateBindingFailure(HttpDiagnostics.IncorrectRandomIntFormat(expression));
+            }
+
+            return node.CreateBindingFailure(HttpDiagnostics.UnableToEvaluateExpression(expression));
+        }
+
+
+        private static HttpBindingResult<object?> GetTimestamp(HttpExpressionNode node, string expressionText, Match match)
+        {
+            if (match.Groups.Count == 3)
+            {
+                var currentDateTimeOffset = DateTimeOffset.UtcNow;
+
+                if (string.Equals(expressionText, "$timestamp"))
+                {
+                    return node.CreateBindingSuccess(currentDateTimeOffset.ToUnixTimeSeconds().ToString());
+                }
+
+                if (match.Groups["offset"].Success && match.Groups["option"].Success)
+                {
+
+                    var offsetString = match.Groups["offset"].Value;
+                    if (int.TryParse(offsetString, out int offset))
+                    {
+                        var optionString = match.Groups["option"].Value;
+
+                        if (currentDateTimeOffset.TryAddOffset(offset, optionString, out var newDateTimeOffset))
+                        {
+                            expressionText = newDateTimeOffset.Value.ToUnixTimeSeconds().ToString();
+                            return node.CreateBindingSuccess(expressionText);
+                        }
+                        else
+                        {
+                            return node.CreateBindingFailure(HttpDiagnostics.InvalidOption(expressionText, optionString));
+                        }
+                    }
+                    else
+                    {
+                        return node.CreateBindingFailure(HttpDiagnostics.InvalidOffset(expressionText, offsetString));
+                    }
+                }
+
+            }
+            return node.CreateBindingFailure(HttpDiagnostics.IncorrectTimestampFormat(expressionText));
+
+        }
+
+        private static HttpBindingResult<object?> GetDateTime(HttpExpressionNode node, string dateTimeType, string expressionText, Match match)
+        {
+            if (match.Groups.Count == 4)
+            {
+                var currentDateTimeOffset = DateTimeOffset.UtcNow;
+                if (match.Groups["offset"].Success && match.Groups["option"].Success)
+                {
+                    var offsetString = match.Groups["offset"].Value;
+                    if (int.TryParse(offsetString, out int offset))
+                    {
+                        var optionString = match.Groups["option"].Value;
+                        if (currentDateTimeOffset.TryAddOffset(offset, optionString, out var newDateTimeOffset))
+                        {
+                            currentDateTimeOffset = newDateTimeOffset.Value;
+                        }
+                        else
+                        {
+                            return node.CreateBindingFailure(HttpDiagnostics.InvalidOption(expressionText, optionString));
+                        }
+                    }
+                    else
+                    {
+                        return node.CreateBindingFailure(HttpDiagnostics.InvalidOffset(expressionText, offsetString));
+                    }
+                }
+                string format;
+                var formatProvider = Thread.CurrentThread.CurrentUICulture;
+                var type = match.Groups["type"];
+
+                string text;
+                if (string.IsNullOrWhiteSpace(type.Value))
+                {
+                    text = currentDateTimeOffset.ToString();
+                }
+                else
+                {
+                    if (string.Equals(type.Value, "rfc1123", StringComparison.OrdinalIgnoreCase))
+                    {
+                        // For RFC1123, we want to be sure to use the invariant culture,
+                        // since we are potentially overriding the format for local date time
+                        // we should explicitly set the format provider to invariant culture
+                        formatProvider = CultureInfo.InvariantCulture;
+                        format = "r";
+                    }
+                    else if (string.Equals(type.Value, "iso8601", StringComparison.OrdinalIgnoreCase))
+                    {
+                        format = "o";
+                    }
+                    else
+                    {
+                        // This substring exists to strip out the double quotes that are expected in a custom format
+                        format = type.Value.Substring(1, type.Value.Length - 2);
+                    }
+
+                    text = currentDateTimeOffset.ToString(format, formatProvider);
+                }
+
+                if (DateTimeOffset.TryParse(text, out _))
+                {
+                    return node.CreateBindingSuccess(text);
+                }
+            }
+            return node.CreateBindingFailure(HttpDiagnostics.IncorrectDateTimeFormat(expressionText, dateTimeType));
+        }
+
+        private static HttpBindingResult<object?> GetRandomInt(HttpExpressionNode node, string text, Match match)
+        {
+            if (TryParseArgumentsFromMatch(text, match, out var min, out var max, out var diagnostic))
+            {
+                Random random = new();
+                if (!min.HasValue && !max.HasValue)
+                {
+                    text = random.Next().ToString();
+                }
+                else if (!min.HasValue && max.HasValue)
+                {
+                    text = random.Next(max.Value).ToString();
+                }
+                else if (min.HasValue && max.HasValue)
+                {
+                    text = random.Next(min.Value, max.Value).ToString();
+                }
+
+                return node.CreateBindingSuccess(text);
+            }
+            else
+            {
+                return node.CreateBindingFailure(diagnostic);
+            }
+
+            bool TryParseArgumentsFromMatch(string expression, Match match, out int? min, out int? max, [NotNullWhen(false)] out HttpDiagnosticInfo? diagnostic)
+            {
+                if (match.Success)
+                {
+                    var group = match.Groups["arguments"];
+                    if (group.Captures.Count == 0)
+                    {
+                        max = null;
+                        min = null;
+                        diagnostic = null;
+                        return true;
+                    }
+                    else if (group.Captures.Count == 1)
+                    {
+                        min = null;
+                        string maxValueString = group.Captures[0].Value;
+                        return TryParseInteger(maxValueString, expression, out max, out diagnostic);
+
+                    }
+
+                    else if (group.Captures.Count == 2)
+                    {
+                        string minValueString = group.Captures[0].Value;
+
+                        if (!TryParseInteger(minValueString, expression, out min, out diagnostic))
+                        {
+                            max = null;
+                            return false;
+                        }
+
+                        string maxValueString = group.Captures[1].Value;
+
+                        if (!TryParseInteger(maxValueString, expression, out max, out diagnostic))
+                        {
+                            min = null;
+                            return false;
+                        }
+
+                        if (min > max)
+                        {
+                            diagnostic = HttpDiagnostics.RandomIntMinMustNotBeGreaterThanMax(expression, min.Value.ToString(), max.Value.ToString());
+                            min = null;
+                            max = null;
+                            return false;
+                        }
+
+                        return true;
+                    }
+                   }
+
+
+                min = null;
+                max = null;
+                diagnostic = HttpDiagnostics.IncorrectRandomIntFormat(expression);
+                return false;
+
+                bool TryParseInteger(string valueString, string expression, [NotNullWhen(true)] out int? value, [NotNullWhen(false)] out HttpDiagnosticInfo? diagnostic)
+                {
+                    if (int.TryParse(valueString, out var result))
+                    {
+                        value = result;
+                        diagnostic = null;
+                        return true;
+                    }
+                    else
+                    {
+                        value = null;
+                        diagnostic = HttpDiagnostics.InvalidRandomIntArgument(expression, valueString);
+                        return false;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/Microsoft.DotNet.Interactive.Http.Parsing/Parsing/HttpRequestNode.cs b/src/Microsoft.DotNet.Interactive.Http.Parsing/Parsing/HttpRequestNode.cs
index 8e3b9fdb2c..0d0cdb84ac 100644
--- a/src/Microsoft.DotNet.Interactive.Http.Parsing/Parsing/HttpRequestNode.cs
+++ b/src/Microsoft.DotNet.Interactive.Http.Parsing/Parsing/HttpRequestNode.cs
@@ -88,6 +88,7 @@ public void Add(HttpCommentNode node)
 
     public HttpBindingResult<HttpRequestMessage> TryGetHttpRequestMessage(HttpBindingDelegate bind)
     {
+        var originalBind = bind;
         var declaredVariables = SyntaxTree?.RootNode.GetDeclaredVariables();
         if (declaredVariables?.Count > 0)
         {
@@ -96,8 +97,8 @@ public HttpBindingResult<HttpRequestMessage> TryGetHttpRequestMessage(HttpBindin
                 if (declaredVariables.TryGetValue(node.Text, out var declaredValue))
                 {
                     return HttpBindingResult<object?>.Success(declaredValue.Value);
-                }
-                else { return bind(node); }
+                } 
+                else { return originalBind(node); }
             };
         }
         var request = new HttpRequestMessage();
diff --git a/src/Microsoft.DotNet.Interactive.Http.Parsing/Parsing/HttpRootSyntaxNode.cs b/src/Microsoft.DotNet.Interactive.Http.Parsing/Parsing/HttpRootSyntaxNode.cs
index 732f6c5fc5..96b673282f 100644
--- a/src/Microsoft.DotNet.Interactive.Http.Parsing/Parsing/HttpRootSyntaxNode.cs
+++ b/src/Microsoft.DotNet.Interactive.Http.Parsing/Parsing/HttpRootSyntaxNode.cs
@@ -57,9 +57,10 @@ public Dictionary<string, DeclaredVariable> GetDeclaredVariables()
                         {
                             return node.CreateBindingSuccess(strinValue);
                         }
+                        
                         else
                         {
-                            return node.CreateBindingFailure(new HttpDiagnosticInfo("1", "invalid variable", CodeAnalysis.DiagnosticSeverity.Error));
+                            return DynamicExpressionUtilites.ResolveExpressionBinding(node, node.Text);
                         }
 
                     });
diff --git a/src/Microsoft.DotNet.Interactive.Http.Tests/HttpKernelTests.cs b/src/Microsoft.DotNet.Interactive.Http.Tests/HttpKernelTests.cs
index 35b650eea0..e51d7776b5 100644
--- a/src/Microsoft.DotNet.Interactive.Http.Tests/HttpKernelTests.cs
+++ b/src/Microsoft.DotNet.Interactive.Http.Tests/HttpKernelTests.cs
@@ -316,6 +316,42 @@ public async Task binding_in_variable_value_is_valid()
 
     }
 
+    [Fact]
+    public async Task binding_variable_in_text_is_valid()
+    {
+        HttpRequestMessage request = null;
+        var handler = new InterceptingHttpMessageHandler((message, _) =>
+        {
+            request = message;
+            var response = new HttpResponseMessage(HttpStatusCode.OK);
+            return Task.FromResult(response);
+        });
+        var client = new HttpClient(handler);
+        using var kernel = new HttpKernel(client: client);
+
+        _ = new AssertionScope();
+
+        var code = """
+            @bar={{$guid}}
+
+            POST https://httpbin.org/anything
+            Content-Type: application/json
+
+            {
+                "request_id": "{{bar}}"
+            }
+            """;
+
+        var result = await kernel.SendAsync(new SubmitCode(code));
+        result.Events.Should().NotContainErrors();
+
+        var bodyAsString = await request.Content.ReadAsStringAsync();
+        var guidSubstring = bodyAsString.Split(":").Last().Trim().Substring(1);
+        var guidString = guidSubstring.Substring(0, guidSubstring.IndexOf("\""));
+        Guid.TryParse(guidString, out _).Should().BeTrue();
+
+    }
+
     [Fact]
     public async Task can_bind_guid()
     {
diff --git a/src/Microsoft.DotNet.Interactive.Http.Tests/ParserTests.Request.cs b/src/Microsoft.DotNet.Interactive.Http.Tests/ParserTests.Request.cs
index d69f257c9f..d4a2399ef3 100644
--- a/src/Microsoft.DotNet.Interactive.Http.Tests/ParserTests.Request.cs
+++ b/src/Microsoft.DotNet.Interactive.Http.Tests/ParserTests.Request.cs
@@ -85,7 +85,7 @@ public void request_node_with_multiple_variables_declared_prior_parsed_correctly
             variableNodes.Count().Should().Be(4);
 
             variableNodes.Select(n => n.DeclarationNode.Text).Should().BeEquivalentTo(new[] { "@searchTerm", "@hostname", "@host", "@createdAt" });
-            variableNodes.Select(n => n.ValueNode.Text).Should().BeEquivalentTo( new[] { "some-search-term", "httpbin.org", "https://{{hostname}}", "{{$datetime iso8601}}" });
+            variableNodes.Select(n => n.ValueNode.Text).Should().BeEquivalentTo(new[] { "some-search-term", "httpbin.org", "https://{{hostname}}", "{{$datetime iso8601}}" });
 
             variableNodes.Last().DescendantNodesAndTokens().OfType<HttpExpressionNode>().Count().Should().Be(1);
         }
diff --git a/src/Microsoft.DotNet.Interactive.Http.Tests/ParserTests.Variables.cs b/src/Microsoft.DotNet.Interactive.Http.Tests/ParserTests.Variables.cs
index c74bc66280..056c2d9ac8 100644
--- a/src/Microsoft.DotNet.Interactive.Http.Tests/ParserTests.Variables.cs
+++ b/src/Microsoft.DotNet.Interactive.Http.Tests/ParserTests.Variables.cs
@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using FluentAssertions;
@@ -10,6 +11,7 @@
 using Microsoft.DotNet.Interactive.Http.Tests.Utility;
 using Microsoft.DotNet.Interactive.Tests.Utility;
 using Xunit;
+using static Microsoft.DotNet.Interactive.Http.Tests.HttpParserTests;
 
 namespace Microsoft.DotNet.Interactive.Http.Tests;
 
@@ -196,6 +198,33 @@ public void declared_variables_using_another_variable_can_be_resolved()
 
         }
 
+        [Fact]
+        public void declared_variable_with_expression_can_be_parsed()
+        {
+            var result = Parse(
+            """
+            @createdAt = {{$datetime iso8601}}
+            @bar={{$guid}}
+
+            POST https://httpbin.org/anything
+            Content-Type: application/json
+
+            {
+                "request_id": "{{bar}}",
+                "created_at": "{{$createdAt}}"
+            }
+            """
+                );
+
+            var variables = result.SyntaxTree.RootNode.GetDeclaredVariables();
+
+            var barValue = variables.Should().Contain(n => n.Key == "bar").Which.Value.Should().BeOfType<DeclaredVariable>().Which.Value;
+            var createAtValue = variables.Should().Contain(n => n.Key == "createdAt").Which.Value.Should().BeOfType<DeclaredVariable>().Which.Value;
+
+            Guid.TryParse(barValue, out var guidResult).Should().BeTrue();
+            DateTime.TryParse(createAtValue, out var dateTimeResult).Should().BeTrue();
+        }
+
         [Fact]
         public void underscores_in_variable_declarations_are_supported()
         {
diff --git a/src/Microsoft.DotNet.Interactive.Http/HttpKernel.cs b/src/Microsoft.DotNet.Interactive.Http/HttpKernel.cs
index 196102b5f5..07f6f0e0bf 100644
--- a/src/Microsoft.DotNet.Interactive.Http/HttpKernel.cs
+++ b/src/Microsoft.DotNet.Interactive.Http/HttpKernel.cs
@@ -321,284 +321,9 @@ private List<Diagnostic> GetAllDiagnostics(HttpRequestParseResult parseResult)
         }
         else
         {
-            return MatchExpressionValue(node, expression);
+            return DynamicExpressionUtilites.ResolveExpressionBinding(node, expression);
         }
 
 
     }
-
-    private HttpBindingResult<object?> MatchExpressionValue(HttpExpressionNode node, string expression)
-    {
-        const string DateTime = "$datetime";
-        const string LocalDateTime = "$localDatetime";
-        const string OffsetRegex = """(?:\s+(?<offset>[-+]?[^\s]+)\s+(?<option>[^\s]+))?""";
-        const string TypeRegex = """(?:\s+(?<type>rfc1123|iso8601|'.+'|".+"))?""";
-
-        var guidPattern = new Regex(@$"^\$guid$", RegexOptions.Compiled);
-        var dateTimePattern = new Regex(@$"^\{DateTime}{TypeRegex}{OffsetRegex}$", RegexOptions.Compiled);
-        var localDateTimePattern = new Regex(@$"^\{LocalDateTime}{TypeRegex}{OffsetRegex}$", RegexOptions.Compiled);
-        var randomIntPattern = new Regex(@$"^\$randomInt(?:\s+(?<arguments>-?[^\s]+)){{0,2}}$", RegexOptions.Compiled);
-        var timestampPattern = new Regex(@$"^\$timestamp{OffsetRegex}$", RegexOptions.Compiled);
-
-
-        var guidMatches = guidPattern.Matches(expression);
-        if (guidMatches.Count == 1)
-        {
-            return node.CreateBindingSuccess(Guid.NewGuid().ToString());
-        }
-
-        if (expression.Contains(DateTime))
-        {
-            var dateTimeMatches = dateTimePattern.Matches(expression);
-            if (dateTimeMatches.Count == 1)
-            {
-                return GetDateTime(node, DateTime, expression, dateTimeMatches.Single());
-            }
-
-            return node.CreateBindingFailure(HttpDiagnostics.IncorrectDateTimeFormat(expression, DateTime));
-        }
-
-        if (expression.Contains(LocalDateTime))
-        {
-            var localDateTimeMatches = localDateTimePattern.Matches(expression);
-            if (localDateTimeMatches.Count == 1)
-            {
-                return GetDateTime(node, LocalDateTime, expression, localDateTimeMatches.Single());
-            }
-
-            return node.CreateBindingFailure(HttpDiagnostics.IncorrectDateTimeFormat(expression, LocalDateTime));
-        }
-
-        if (expression.Contains("$timestamp"))
-        {
-            var timestampMatches = timestampPattern.Matches(expression);
-            if (timestampMatches.Count == 1)
-            {
-                return GetTimestamp(node, expression, timestampMatches.Single());
-            }
-
-            return node.CreateBindingFailure(HttpDiagnostics.IncorrectTimestampFormat(expression));
-        }
-
-        if (expression.Contains("$randomInt"))
-        {
-            var randomIntMatches = randomIntPattern.Matches(expression);
-            if (randomIntMatches.Count == 1)
-            {
-                return GetRandInt(node, expression, randomIntMatches.Single());
-            }
-
-            return node.CreateBindingFailure(HttpDiagnostics.IncorrectRandomIntFormat(expression));
-        }
-
-        return node.CreateBindingFailure(HttpDiagnostics.UnableToEvaluateExpression(expression));
-    }
-
-
-    private HttpBindingResult<object?> GetTimestamp(HttpExpressionNode node, string expressionText, Match match)
-    {
-        if (match.Groups.Count == 3)
-        {
-            var currentDateTimeOffset = DateTimeOffset.UtcNow;
-
-            if (string.Equals(expressionText, "$timestamp"))
-            {
-                return node.CreateBindingSuccess(currentDateTimeOffset.ToUnixTimeSeconds().ToString());
-            }
-
-            if (match.Groups["offset"].Success && match.Groups["option"].Success)
-            {
-
-                var offsetString = match.Groups["offset"].Value;
-                if (int.TryParse(offsetString, out int offset))
-                {
-                    var optionString = match.Groups["option"].Value;
-
-                    if (currentDateTimeOffset.TryAddOffset(offset, optionString, out var newDateTimeOffset))
-                    {
-                        expressionText = newDateTimeOffset.Value.ToUnixTimeSeconds().ToString();
-                        return node.CreateBindingSuccess(expressionText);
-                    }
-                    else
-                    {
-                        return node.CreateBindingFailure(HttpDiagnostics.InvalidOption(expressionText, optionString));
-                    }
-                }
-                else
-                {
-                    return node.CreateBindingFailure(HttpDiagnostics.InvalidOffset(expressionText, offsetString));
-                }
-            }
-
-        }
-        return node.CreateBindingFailure(HttpDiagnostics.IncorrectTimestampFormat(expressionText));
-
-    }
-
-    private HttpBindingResult<object?> GetDateTime(HttpExpressionNode node, string dateTimeType, string expressionText, Match match)
-    {
-        if (match.Groups.Count == 4)
-        {
-            var currentDateTimeOffset = DateTimeOffset.UtcNow;
-            if (match.Groups["offset"].Success && match.Groups["option"].Success)
-            {
-                var offsetString = match.Groups["offset"].Value;
-                if (int.TryParse(offsetString, out int offset))
-                {
-                    var optionString = match.Groups["option"].Value;
-                    if (currentDateTimeOffset.TryAddOffset(offset, optionString, out var newDateTimeOffset))
-                    {
-                        currentDateTimeOffset = newDateTimeOffset.Value;
-                    }
-                    else
-                    {
-                        return node.CreateBindingFailure(HttpDiagnostics.InvalidOption(expressionText, optionString));
-                    }
-                }
-                else
-                {
-                    return node.CreateBindingFailure(HttpDiagnostics.InvalidOffset(expressionText, offsetString));
-                }
-            }
-            string format;
-            var formatProvider = Thread.CurrentThread.CurrentUICulture;
-            var type = match.Groups["type"];
-
-            string text;
-            if (string.IsNullOrWhiteSpace(type.Value))
-            {
-                text = currentDateTimeOffset.ToString();
-            }
-            else
-            {
-                if (string.Equals(type.Value, "rfc1123", StringComparison.OrdinalIgnoreCase))
-                {
-                    // For RFC1123, we want to be sure to use the invariant culture,
-                    // since we are potentially overriding the format for local date time
-                    // we should explicitly set the format provider to invariant culture
-                    formatProvider = CultureInfo.InvariantCulture;
-                    format = "r";
-                }
-                else if (string.Equals(type.Value, "iso8601", StringComparison.OrdinalIgnoreCase))
-                {
-                    format = "o";
-                }
-                else
-                {
-                    // This substring exists to strip out the double quotes that are expected in a custom format
-                    format = type.Value.Substring(1, type.Value.Length - 2);
-                }
-
-                text = currentDateTimeOffset.ToString(format, formatProvider);
-            }
-
-            if (DateTimeOffset.TryParse(text, out _))
-            {
-                return node.CreateBindingSuccess(text);
-            }
-        }
-        return node.CreateBindingFailure(HttpDiagnostics.IncorrectDateTimeFormat(expressionText, dateTimeType));
-    }
-
-    private HttpBindingResult<object?> GetRandInt(HttpExpressionNode node, string text, Match match)
-    {
-        if (TryParseArgumentsFromMatch(text, match, out var min, out var max, out var diagnostic))
-        {
-            Random random = new();
-            if (!min.HasValue && !max.HasValue)
-            {
-                text = random.Next().ToString();
-            }
-            else if (!min.HasValue && max.HasValue)
-            {
-                text = random.Next(max.Value).ToString();
-            }
-            else if (min.HasValue && max.HasValue)
-            {
-                text = random.Next(min.Value, max.Value).ToString();
-            }
-
-            return node.CreateBindingSuccess(text);
-        }
-        else
-        {
-            return node.CreateBindingFailure(diagnostic);
-        }
-
-        bool TryParseArgumentsFromMatch(string expression, Match match, out int? min, out int? max, [NotNullWhen(false)] out HttpDiagnosticInfo? diagnostic)
-        {
-            if (match.Success)
-            {
-                var group = match.Groups["arguments"];
-                if (group.Captures.Count == 0)
-                {
-                    max = null;
-                    min = null;
-                    diagnostic = null;
-                    return true;
-                }
-                else if (group.Captures.Count == 1)
-                {
-                    min = null;
-                    string maxValueString = group.Captures[0].Value;
-                    return TryParseInteger(maxValueString, expression, out max, out diagnostic);
-
-                }
-
-                else if (group.Captures.Count == 2)
-                {
-                    string minValueString = group.Captures[0].Value;
-
-                    if (!TryParseInteger(minValueString, expression, out min, out diagnostic))
-                    {
-                        max = null;
-                        return false;
-                    }
-
-                    string maxValueString = group.Captures[1].Value;
-
-                    if (!TryParseInteger(maxValueString, expression, out max, out diagnostic))
-                    {
-                        min = null;
-                        return false;
-                    }
-
-                    if (min > max)
-                    {
-                        diagnostic = HttpDiagnostics.RandomIntMinMustNotBeGreaterThanMax(expression, min.Value.ToString(), max.Value.ToString());
-                        min = null;
-                        max = null;
-                        return false;
-                    }
-
-                    return true;
-                }
-
-            }
-
-            min = null;
-            max = null;
-            diagnostic = HttpDiagnostics.IncorrectRandomIntFormat(expression);
-            return false;
-
-            bool TryParseInteger(string valueString, string expression, [NotNullWhen(true)] out int? value, [NotNullWhen(false)] out HttpDiagnosticInfo? diagnostic)
-            {
-                if (int.TryParse(valueString, out var result))
-                {
-                    value = result;
-                    diagnostic = null;
-                    return true;
-                }
-                else
-                {
-                    value = null;
-                    diagnostic = HttpDiagnostics.InvalidRandomIntArgument(expression, valueString);
-                    return false;
-                }
-            }
-        }
-    }
-
-
-
 }
\ No newline at end of file