@typespec/http-specs 0.1.0-alpha.9 → 0.1.0-dev.0

package/specs/encode/duration/main.tsp

@@ -45,6 +45,19 @@ namespace Query {
     input: duration,
   ): NoContentResponse;
 
+  @route("/int32-seconds-larger-unit")
+  @scenario
+  @scenarioDoc("""
+    Test int32 seconds encode for a duration parameter where the duration is several minutes.
+    Languages that support duration primitives should use the largest possible unit, e.g. TimeSpan.FromMinutes(2) in C#.
+    Expected query parameter `input=120`
+    """)
+  op int32SecondsLargerUnit(
+    @query
+    @encode(DurationKnownEncoding.seconds, int32)
+    input: duration,
+  ): NoContentResponse;
+
   @route("/float-seconds")
   @scenario
   @scenarioDoc("""
@@ -57,6 +70,19 @@ namespace Query {
     input: duration,
   ): NoContentResponse;
 
+  @route("/float-seconds-larger-unit")
+  @scenario
+  @scenarioDoc("""
+    Test float seconds encode for a duration parameter where the duration is several minutes.
+    Languages that support duration primitives should use the largest possible unit, e.g. TimeSpan.FromMinutes(2.5) in C#.
+    Expected query parameter `input=150.0`
+    """)
+  op floatSecondsLargerUnit(
+    @query
+    @encode(DurationKnownEncoding.seconds, float)
+    input: duration,
+  ): NoContentResponse;
+
   @route("/float64-seconds")
   @scenario
   @scenarioDoc("""
@@ -69,6 +95,68 @@ namespace Query {
     input: duration,
   ): NoContentResponse;
 
+  @route("/int32-milliseconds")
+  @scenario
+  @scenarioDoc("""
+    Test int32 milliseconds encode for a duration parameter.
+    Expected query parameter `input=36000`
+    """)
+  op int32Milliseconds(
+    @query
+    @encode(DurationKnownEncoding.milliseconds, int32)
+    input: duration,
+  ): NoContentResponse;
+
+  @route("/int32-milliseconds-larger-unit")
+  @scenario
+  @scenarioDoc("""
+    Test int32 milliseconds encode for a duration parameter where the duration is several minutes.
+    Languages that support duration primitives should use the largest possible unit, e.g. TimeSpan.FromMinutes(3) in C#.
+    Expected query parameter `input=180000`
+    """)
+  op int32MillisecondsLargerUnit(
+    @query
+    @encode(DurationKnownEncoding.milliseconds, int32)
+    input: duration,
+  ): NoContentResponse;
+
+  @route("/float-milliseconds")
+  @scenario
+  @scenarioDoc("""
+    Test float milliseconds encode for a duration parameter.
+    Expected query parameter `input=35625`
+    """)
+  op floatMilliseconds(
+    @query
+    @encode(DurationKnownEncoding.milliseconds, float)
+    input: duration,
+  ): NoContentResponse;
+
+  @route("/float-milliseconds-larger-unit")
+  @scenario
+  @scenarioDoc("""
+    Test float milliseconds encode for a duration parameter where the duration is several minutes.
+    Languages that support duration primitives should use the largest possible unit, e.g. TimeSpan.FromMinutes(3.5) in C#.
+    Expected query parameter `input=210000.0`
+    """)
+  op floatMillisecondsLargerUnit(
+    @query
+    @encode(DurationKnownEncoding.milliseconds, float)
+    input: duration,
+  ): NoContentResponse;
+
+  @route("/float64-milliseconds")
+  @scenario
+  @scenarioDoc("""
+    Test float64 milliseconds encode for a duration parameter.
+    Expected query parameter `input=35625`
+    """)
+  op float64Milliseconds(
+    @query
+    @encode(DurationKnownEncoding.milliseconds, float64)
+    input: duration,
+  ): NoContentResponse;
+
   @encode(DurationKnownEncoding.seconds, int32)
   scalar Int32Duration extends duration;
 
@@ -79,12 +167,23 @@ namespace Query {
     Expected query parameter `input=36,47`
     """)
   op int32SecondsArray(
-    #suppress "deprecated" "Deprecated in next release"
-    @query({
-      format: "csv",
-    })
+    @query
     input: Int32Duration[],
   ): NoContentResponse;
+
+  @encode(DurationKnownEncoding.milliseconds, int32)
+  scalar Int32MillisecondsDuration extends duration;
+
+  @route("/int32-milliseconds-array")
+  @scenario
+  @scenarioDoc("""
+    Test int32 milliseconds encode for a duration array parameter.
+    Expected query parameter `input=36000,47000`
+    """)
+  op int32MillisecondsArray(
+    @query
+    input: Int32MillisecondsDuration[],
+  ): NoContentResponse;
 }
 
 @route("/property")
@@ -113,6 +212,41 @@ namespace Property {
     value: duration;
   }
 
+  model Int32MillisecondsDurationProperty {
+    @encode(DurationKnownEncoding.milliseconds, int32)
+    value: duration;
+  }
+
+  model FloatMillisecondsDurationProperty {
+    @encode(DurationKnownEncoding.milliseconds, float)
+    value: duration;
+  }
+
+  model Float64MillisecondsDurationProperty {
+    @encode(DurationKnownEncoding.milliseconds, float64)
+    value: duration;
+  }
+
+  model Int32SecondsLargerUnitDurationProperty {
+    @encode(DurationKnownEncoding.seconds, int32)
+    value: duration;
+  }
+
+  model FloatSecondsLargerUnitDurationProperty {
+    @encode(DurationKnownEncoding.seconds, float)
+    value: duration;
+  }
+
+  model Int32MillisecondsLargerUnitDurationProperty {
+    @encode(DurationKnownEncoding.milliseconds, int32)
+    value: duration;
+  }
+
+  model FloatMillisecondsLargerUnitDurationProperty {
+    @encode(DurationKnownEncoding.milliseconds, float)
+    value: duration;
+  }
+
   @encode(DurationKnownEncoding.seconds, float32)
   scalar Float32Duration extends duration;
 
@@ -120,6 +254,13 @@ namespace Property {
     value: Float32Duration[];
   }
 
+  @encode(DurationKnownEncoding.milliseconds, float32)
+  scalar Float32MillisecondsDuration extends duration;
+
+  model FloatMillisecondsDurationArrayProperty {
+    value: Float32MillisecondsDuration[];
+  }
+
   @route("/default")
   @scenario
   @scenarioDoc("""
@@ -217,6 +358,69 @@ namespace Property {
     """)
   op float64Seconds(@body body: Float64SecondsDurationProperty): Float64SecondsDurationProperty;
 
+  @route("/int32-milliseconds")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains a duration property with int32 milliseconds encode.
+    Expected request body:
+    ```json
+    {
+      "value": 36000
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": 36000
+    }
+    ```
+    """)
+  op int32Milliseconds(
+    @body body: Int32MillisecondsDurationProperty,
+  ): Int32MillisecondsDurationProperty;
+
+  @route("/float-milliseconds")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains a duration property with float milliseconds encode.
+    Expected request body:
+    ```json
+    {
+      "value": 35625
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": 35625
+    }
+    ```
+    """)
+  op floatMilliseconds(
+    @body body: FloatMillisecondsDurationProperty,
+  ): FloatMillisecondsDurationProperty;
+
+  @route("/float64-milliseconds")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains a duration property with float64 milliseconds encode.
+    Expected request body:
+    ```json
+    {
+      "value": 35625
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": 35625
+    }
+    ```
+    """)
+  op float64Milliseconds(
+    @body body: Float64MillisecondsDurationProperty,
+  ): Float64MillisecondsDurationProperty;
+
   @route("/float-seconds-array")
   @scenario
   @scenarioDoc("""
@@ -237,6 +441,115 @@ namespace Property {
   op floatSecondsArray(
     @body body: FloatSecondsDurationArrayProperty,
   ): FloatSecondsDurationArrayProperty;
+
+  @route("/float-milliseconds-array")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains an array property which elements are duration with float milliseconds encode.
+    Expected request body:
+    ```json
+    {
+      "value": [35625, 46750]
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": [35625, 46750]
+    }
+    ```
+    """)
+  op floatMillisecondsArray(
+    @body body: FloatMillisecondsDurationArrayProperty,
+  ): FloatMillisecondsDurationArrayProperty;
+
+  @route("/int32-seconds-larger-unit")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains a duration property with int32 seconds encode where the duration is several minutes.
+    Languages that support duration primitives should use the largest possible unit, e.g. TimeSpan.FromMinutes(2) in C#.
+    Expected request body:
+    ```json
+    {
+      "value": 120
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": 120
+    }
+    ```
+    """)
+  op int32SecondsLargerUnit(
+    @body body: Int32SecondsLargerUnitDurationProperty,
+  ): Int32SecondsLargerUnitDurationProperty;
+
+  @route("/float-seconds-larger-unit")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains a duration property with float seconds encode where the duration is several minutes.
+    Languages that support duration primitives should use the largest possible unit, e.g. TimeSpan.FromMinutes(2.5) in C#.
+    Expected request body:
+    ```json
+    {
+      "value": 150.0
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": 150.0
+    }
+    ```
+    """)
+  op floatSecondsLargerUnit(
+    @body body: FloatSecondsLargerUnitDurationProperty,
+  ): FloatSecondsLargerUnitDurationProperty;
+
+  @route("/int32-milliseconds-larger-unit")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains a duration property with int32 milliseconds encode where the duration is several minutes.
+    Languages that support duration primitives should use the largest possible unit, e.g. TimeSpan.FromMinutes(3) in C#.
+    Expected request body:
+    ```json
+    {
+      "value": 180000
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": 180000
+    }
+    ```
+    """)
+  op int32MillisecondsLargerUnit(
+    @body body: Int32MillisecondsLargerUnitDurationProperty,
+  ): Int32MillisecondsLargerUnitDurationProperty;
+
+  @route("/float-milliseconds-larger-unit")
+  @scenario
+  @scenarioDoc("""
+    Test operation with request and response model contains a duration property with float milliseconds encode where the duration is several minutes.
+    Languages that support duration primitives should use the largest possible unit, e.g. TimeSpan.FromMinutes(3.5) in C#.
+    Expected request body:
+    ```json
+    {
+      "value": 210000.0
+    }
+    ```
+    Expected response body:
+    ```json
+    {
+      "value": 210000.0
+    }
+    ```
+    """)
+  op floatMillisecondsLargerUnit(
+    @body body: FloatMillisecondsLargerUnitDurationProperty,
+  ): FloatMillisecondsLargerUnitDurationProperty;
 }
 
 @route("/header")
@@ -274,9 +587,7 @@ namespace Header {
     Expected header `duration: [P40D,P50D]`
     """)
   op iso8601Array(
-    @header({
-      format: "csv",
-    })
+    @header
     duration: Iso8601Duration[],
   ): NoContentResponse;
 
@@ -292,6 +603,19 @@ namespace Header {
     duration: duration,
   ): NoContentResponse;
 
+  @route("/int32-seconds-larger-unit")
+  @scenario
+  @scenarioDoc("""
+    Test int32 seconds encode for a duration header where the duration is several minutes.
+    Languages that support duration primitives should use the largest possible unit, e.g. TimeSpan.FromMinutes(2) in C#.
+    Expected header `duration: 120`
+    """)
+  op int32SecondsLargerUnit(
+    @header
+    @encode(DurationKnownEncoding.seconds, int32)
+    duration: duration,
+  ): NoContentResponse;
+
   @route("/float-seconds")
   @scenario
   @scenarioDoc("""
@@ -304,6 +628,19 @@ namespace Header {
     duration: duration,
   ): NoContentResponse;
 
+  @route("/float-seconds-larger-unit")
+  @scenario
+  @scenarioDoc("""
+    Test float seconds encode for a duration header where the duration is several minutes.
+    Languages that support duration primitives should use the largest possible unit, e.g. TimeSpan.FromMinutes(2.5) in C#.
+    Expected header `duration: 150.0`
+    """)
+  op floatSecondsLargerUnit(
+    @header
+    @encode(DurationKnownEncoding.seconds, float)
+    duration: duration,
+  ): NoContentResponse;
+
   @route("/float64-seconds")
   @scenario
   @scenarioDoc("""
@@ -315,4 +652,80 @@ namespace Header {
     @encode(DurationKnownEncoding.seconds, float64)
     duration: duration,
   ): NoContentResponse;
+
+  @route("/int32-milliseconds")
+  @scenario
+  @scenarioDoc("""
+    Test int32 milliseconds encode for a duration header.
+    Expected header `duration: 36000`
+    """)
+  op int32Milliseconds(
+    @header
+    @encode(DurationKnownEncoding.milliseconds, int32)
+    duration: duration,
+  ): NoContentResponse;
+
+  @route("/int32-milliseconds-larger-unit")
+  @scenario
+  @scenarioDoc("""
+    Test int32 milliseconds encode for a duration header where the duration is several minutes.
+    Languages that support duration primitives should use the largest possible unit, e.g. TimeSpan.FromMinutes(3) in C#.
+    Expected header `duration: 180000`
+    """)
+  op int32MillisecondsLargerUnit(
+    @header
+    @encode(DurationKnownEncoding.milliseconds, int32)
+    duration: duration,
+  ): NoContentResponse;
+
+  @route("/float-milliseconds")
+  @scenario
+  @scenarioDoc("""
+    Test float milliseconds encode for a duration header.
+    Expected header `duration: 35625`
+    """)
+  op floatMilliseconds(
+    @header
+    @encode(DurationKnownEncoding.milliseconds, float)
+    duration: duration,
+  ): NoContentResponse;
+
+  @route("/float-milliseconds-larger-unit")
+  @scenario
+  @scenarioDoc("""
+    Test float milliseconds encode for a duration header where the duration is several minutes.
+    Languages that support duration primitives should use the largest possible unit, e.g. TimeSpan.FromMinutes(3.5) in C#.
+    Expected header `duration: 210000.0`
+    """)
+  op floatMillisecondsLargerUnit(
+    @header
+    @encode(DurationKnownEncoding.milliseconds, float)
+    duration: duration,
+  ): NoContentResponse;
+
+  @route("/float64-milliseconds")
+  @scenario
+  @scenarioDoc("""
+    Test float64 milliseconds encode for a duration header.
+    Expected header `duration: 35625`
+    """)
+  op float64Milliseconds(
+    @header
+    @encode(DurationKnownEncoding.milliseconds, float64)
+    duration: duration,
+  ): NoContentResponse;
+
+  @encode(DurationKnownEncoding.milliseconds, int32)
+  scalar Int32MillisecondsDuration extends duration;
+
+  @route("/int32-milliseconds-array")
+  @scenario
+  @scenarioDoc("""
+    Test int32 milliseconds encode for a duration array header.
+    Expected header `duration: [36000,47000]`
+    """)
+  op int32MillisecondsArray(
+    @header
+    duration: Int32MillisecondsDuration[],
+  ): NoContentResponse;
 }