@typespec/http-specs 0.1.0-alpha.0

package/specs/type/array/main.tsp

@@ -0,0 +1,108 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@doc("Illustrates various types of arrays.")
+@scenarioService("/type/array")
+namespace Type.Array;
+
+@doc("Template to have Array operations")
+interface ArrayOperations<TArr, TDoc extends valueof string> {
+  @scenario
+  @scenarioDoc("""
+    Expected Array response body:
+    ```json
+    ${TDoc}
+    ```
+    """)
+  @get
+  get(): TArr;
+
+  @scenario
+  @scenarioDoc("""
+    Expected Array input body:
+    ```json
+    ${TDoc}
+    ```
+    """)
+  @put
+  put(@body body: TArr): void;
+}
+
+@doc("Array of int32 values")
+@route("/int32")
+interface Int32Value extends ArrayOperations<int32[], "[1, 2]"> {}
+
+@doc("Array of int64 values")
+@route("/int64")
+interface Int64Value
+  extends ArrayOperations<int64[], "[0x7FFFFFFFFFFFFFFF, -0x7FFFFFFFFFFFFFFF]"> {}
+
+@doc("Array of boolean values")
+@route("/boolean")
+interface BooleanValue extends ArrayOperations<boolean[], "[true, false]"> {}
+
+@doc("Array of string values")
+@route("/string")
+interface StringValue extends ArrayOperations<string[], "['hello', '']"> {}
+
+@doc("Array of float values")
+@route("/float32")
+interface Float32Value extends ArrayOperations<float32[], "[43.125]"> {}
+
+@doc("Array of datetime values")
+@route("/datetime")
+interface DatetimeValue extends ArrayOperations<utcDateTime[], "['2022-08-26T18:38:00Z']"> {}
+
+@doc("Array of duration values")
+@route("/duration")
+interface DurationValue extends ArrayOperations<duration[], "['P123DT22H14M12.011S']"> {}
+
+@doc("Array of unknown values")
+@route("/unknown")
+interface UnknownValue extends ArrayOperations<unknown[], "[1, 'hello', 'k3': null]"> {}
+
+@doc("Array inner model")
+model InnerModel {
+  @doc("Required string property")
+  property: string;
+
+  children?: InnerModel[];
+}
+
+@doc("Array of model values")
+@route("/model")
+interface ModelValue
+  extends ArrayOperations<InnerModel[], "[{'property': 'hello'}, {'property': 'world'}]"> {}
+
+alias NullableFloat = float32 | null;
+@doc("Array of nullable float values")
+@route("/nullable-float")
+interface NullableFloatValue extends ArrayOperations<NullableFloat[], "[1.25, null, 3.0]"> {}
+
+alias NullableInt32 = int32 | null;
+@doc("Array of nullable int32 values")
+@route("/nullable-int32")
+interface NullableInt32Value extends ArrayOperations<NullableInt32[], "[1, null, 3]"> {}
+
+alias NullableBoolean = boolean | null;
+@doc("Array of nullable boolean values")
+@route("/nullable-boolean")
+interface NullableBooleanValue extends ArrayOperations<NullableBoolean[], "[true, null, false]"> {}
+
+alias NullableString = string | null;
+@doc("Array of nullable string values")
+@route("/nullable-string")
+interface NullableStringValue
+  extends ArrayOperations<NullableString[], "['hello', null, 'world']"> {}
+
+alias NullableModel = InnerModel | null;
+@doc("Array of nullable model values")
+@route("/nullable-model")
+interface NullableModelValue
+  extends ArrayOperations<
+      NullableModel[],
+      "[{'property': 'hello'}, null, {'property': 'world'}]"
+    > {}

package/specs/type/array/mockapi.ts

@@ -0,0 +1,107 @@
+import { json, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+function createServerTests(uri: string, data: any) {
+  return {
+    get: passOnSuccess({
+      uri,
+      method: "get",
+      request: {},
+      response: {
+        status: 200,
+        body: json(data),
+      },
+      kind: "MockApiDefinition",
+    }),
+    put: passOnSuccess({
+      uri,
+      method: "put",
+      request: {
+        body: data,
+      },
+      response: {
+        status: 204,
+      },
+      kind: "MockApiDefinition",
+    }),
+  };
+}
+
+const Type_Array_Int32 = createServerTests(`/type/array/int32`, [1, 2]);
+Scenarios.Type_Array_Int32Value_get = Type_Array_Int32.get;
+Scenarios.Type_Array_Int32Value_put = Type_Array_Int32.put;
+
+const Type_Array_Int64 = createServerTests(`/type/array/int64`, [
+  Number.MAX_SAFE_INTEGER,
+  Number.MIN_SAFE_INTEGER,
+]);
+Scenarios.Type_Array_Int64Value_get = Type_Array_Int64.get;
+Scenarios.Type_Array_Int64Value_put = Type_Array_Int64.put;
+
+const Type_Array_Boolean = createServerTests(`/type/array/boolean`, [true, false]);
+Scenarios.Type_Array_BooleanValue_get = Type_Array_Boolean.get;
+Scenarios.Type_Array_BooleanValue_put = Type_Array_Boolean.put;
+
+const Type_Array_String = createServerTests(`/type/array/string`, ["hello", ""]);
+Scenarios.Type_Array_StringValue_get = Type_Array_String.get;
+Scenarios.Type_Array_StringValue_put = Type_Array_String.put;
+
+const Type_Array_Float32 = createServerTests(`/type/array/float32`, [43.125]);
+Scenarios.Type_Array_Float32Value_get = Type_Array_Float32.get;
+Scenarios.Type_Array_Float32Value_put = Type_Array_Float32.put;
+
+const Type_Array_Datetime = createServerTests(`/type/array/datetime`, ["2022-08-26T18:38:00Z"]);
+Scenarios.Type_Array_DatetimeValue_get = Type_Array_Datetime.get;
+Scenarios.Type_Array_DatetimeValue_put = Type_Array_Datetime.put;
+
+const Type_Array_Duration = createServerTests(`/type/array/duration`, ["P123DT22H14M12.011S"]);
+Scenarios.Type_Array_DurationValue_get = Type_Array_Duration.get;
+Scenarios.Type_Array_DurationValue_put = Type_Array_Duration.put;
+
+const Type_Array_Unknown = createServerTests(`/type/array/unknown`, [1, "hello", null]);
+Scenarios.Type_Array_UnknownValue_get = Type_Array_Unknown.get;
+Scenarios.Type_Array_UnknownValue_put = Type_Array_Unknown.put;
+
+const Type_Array_Model = createServerTests(`/type/array/model`, [
+  { property: "hello" },
+  { property: "world" },
+]);
+Scenarios.Type_Array_ModelValue_get = Type_Array_Model.get;
+Scenarios.Type_Array_ModelValue_put = Type_Array_Model.put;
+
+const Type_Array_Nullable_Float = createServerTests(`/type/array/nullable-float`, [
+  1.25,
+  null,
+  3.0,
+]);
+Scenarios.Type_Array_NullableFloatValue_get = Type_Array_Nullable_Float.get;
+Scenarios.Type_Array_NullableFloatValue_put = Type_Array_Nullable_Float.put;
+
+const Type_Array_Nullable_Boolean = createServerTests(`/type/array/nullable-boolean`, [
+  true,
+  null,
+  false,
+]);
+Scenarios.Type_Array_NullableBooleanValue_get = Type_Array_Nullable_Boolean.get;
+Scenarios.Type_Array_NullableBooleanValue_put = Type_Array_Nullable_Boolean.put;
+
+const Type_Array_Nullable_Int32 = createServerTests(`/type/array/nullable-int32`, [1, null, 3]);
+Scenarios.Type_Array_NullableInt32Value_get = Type_Array_Nullable_Int32.get;
+Scenarios.Type_Array_NullableInt32Value_put = Type_Array_Nullable_Int32.put;
+
+const Type_Array_Nullable_String = createServerTests(`/type/array/nullable-string`, [
+  "hello",
+  null,
+  "world",
+]);
+Scenarios.Type_Array_NullableStringValue_get = Type_Array_Nullable_String.get;
+Scenarios.Type_Array_NullableStringValue_put = Type_Array_Nullable_String.put;
+
+const Type_Array_Nullable_Model = createServerTests(`/type/array/nullable-model`, [
+  { property: "hello" },
+  null,
+  { property: "world" },
+]);
+Scenarios.Type_Array_NullableModelValue_get = Type_Array_Nullable_Model.get;
+Scenarios.Type_Array_NullableModelValue_put = Type_Array_Nullable_Model.put;

package/specs/type/dictionary/main.tsp

@@ -0,0 +1,101 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@doc("Illustrates various of dictionaries.")
+@scenarioService("/type/dictionary")
+namespace Type.Dictionary;
+
+@doc("Template to have dictionary operations")
+interface DictionaryOperations<TDict, TDoc extends valueof string> {
+  @scenario
+  @scenarioDoc("""
+    Expected dictionary response body:
+    ```json
+    ${TDoc}
+    ```
+    """)
+  @get
+  get(): TDict;
+
+  @scenario
+  @scenarioDoc("""
+    Expected dictionary input body:
+    ```json
+    ${TDoc}
+    ```
+    """)
+  @put
+  put(@body body: TDict): void;
+}
+
+@doc("Dictionary of int32 values")
+@route("/int32")
+interface Int32Value extends DictionaryOperations<Record<int32>, "{'k1': 1, 'k2': 2}"> {}
+
+@doc("Dictionary of int64 values")
+@route("/int64")
+interface Int64Value
+  extends DictionaryOperations<
+      Record<int64>,
+      "{'k1': 0x7FFFFFFFFFFFFFFF, 'k2': -0x7FFFFFFFFFFFFFFF}"
+    > {}
+
+@doc("Dictionary of boolean values")
+@route("/boolean")
+interface BooleanValue extends DictionaryOperations<Record<boolean>, "{'k1': true, 'k2': false}"> {}
+
+@doc("Dictionary of string values")
+@route("/string")
+interface StringValue extends DictionaryOperations<Record<string>, "{'k1': 'hello', 'k2': ''}"> {}
+
+@doc("Dictionary of float values")
+@route("/float32")
+interface Float32Value extends DictionaryOperations<Record<float32>, "{'k1': 43.125}"> {}
+
+@doc("Dictionary of datetime values")
+@route("/datetime")
+interface DatetimeValue
+  extends DictionaryOperations<Record<utcDateTime>, "{'k1': '2022-08-26T18:38:00Z'}"> {}
+
+@doc("Dictionary of duration values")
+@route("/duration")
+interface DurationValue
+  extends DictionaryOperations<Record<duration>, "{'k1': 'P123DT22H14M12.011S'}"> {}
+
+@doc("Dictionary of unknown values")
+@route("/unknown")
+interface UnknownValue
+  extends DictionaryOperations<Record<unknown>, "{'k1': 1, 'k2': 'hello', 'k3': null}"> {}
+
+@doc("Dictionary inner model")
+model InnerModel {
+  @doc("Required string property")
+  property: string;
+
+  children?: Record<InnerModel>;
+}
+
+@doc("Dictionary of model values")
+@route("/model")
+interface ModelValue
+  extends DictionaryOperations<
+      Record<InnerModel>,
+      "{'k1': {'property': 'hello'}, 'k2': {'property': 'world'}}"
+    > {}
+
+@doc("Dictionary of model values")
+@route("/model/recursive")
+interface RecursiveModelValue
+  extends DictionaryOperations<
+      Record<InnerModel>,
+      "{'k1': {'property': 'hello', children: {}}, 'k2': {'property': 'world', children: {'k2.1': {'property': 'inner world'}}}}"
+    > {}
+
+alias NullableFloat = float32 | null;
+@doc("Dictionary of nullable float values")
+@route("/nullable-float")
+interface NullableFloatValue
+  extends DictionaryOperations<Record<NullableFloat>, "{'k1': 1.25, 'k2': 0.5, 'k3': null}"> {}

package/specs/type/dictionary/mockapi.ts

@@ -0,0 +1,103 @@
+import { json, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+function createServerTests(uri: string, data: any) {
+  return {
+    get: passOnSuccess({
+      uri,
+      method: "get",
+      request: {},
+      response: {
+        status: 200,
+        body: json(data),
+      },
+      kind: "MockApiDefinition",
+    }),
+    put: passOnSuccess({
+      uri,
+      method: "put",
+      request: {
+        body: data,
+      },
+      response: {
+        status: 204,
+      },
+      kind: "MockApiDefinition",
+    }),
+  };
+}
+
+const Type_Dictionary_Int32 = createServerTests(`/type/dictionary/int32`, { k1: 1, k2: 2 });
+Scenarios.Type_Dictionary_Int32Value_get = Type_Dictionary_Int32.get;
+Scenarios.Type_Dictionary_Int32Value_put = Type_Dictionary_Int32.put;
+
+const Type_Dictionary_Int64 = createServerTests(`/type/dictionary/int64`, {
+  k1: Number.MAX_SAFE_INTEGER,
+  k2: Number.MIN_SAFE_INTEGER,
+});
+Scenarios.Type_Dictionary_Int64Value_get = Type_Dictionary_Int64.get;
+Scenarios.Type_Dictionary_Int64Value_put = Type_Dictionary_Int64.put;
+
+const Type_Dictionary_Boolean = createServerTests(`/type/dictionary/boolean`, {
+  k1: true,
+  k2: false,
+});
+Scenarios.Type_Dictionary_BooleanValue_get = Type_Dictionary_Boolean.get;
+Scenarios.Type_Dictionary_BooleanValue_put = Type_Dictionary_Boolean.put;
+
+const Type_Dictionary_String = createServerTests(`/type/dictionary/string`, {
+  k1: "hello",
+  k2: "",
+});
+Scenarios.Type_Dictionary_StringValue_get = Type_Dictionary_String.get;
+Scenarios.Type_Dictionary_StringValue_put = Type_Dictionary_String.put;
+
+const Type_Dictionary_Float32 = createServerTests(`/type/dictionary/float32`, { k1: 43.125 });
+Scenarios.Type_Dictionary_Float32Value_get = Type_Dictionary_Float32.get;
+Scenarios.Type_Dictionary_Float32Value_put = Type_Dictionary_Float32.put;
+
+const Type_Dictionary_Datetime = createServerTests(`/type/dictionary/datetime`, {
+  k1: "2022-08-26T18:38:00Z",
+});
+Scenarios.Type_Dictionary_DatetimeValue_get = Type_Dictionary_Datetime.get;
+Scenarios.Type_Dictionary_DatetimeValue_put = Type_Dictionary_Datetime.put;
+
+const Type_Dictionary_Duration = createServerTests(`/type/dictionary/duration`, {
+  k1: "P123DT22H14M12.011S",
+});
+Scenarios.Type_Dictionary_DurationValue_get = Type_Dictionary_Duration.get;
+Scenarios.Type_Dictionary_DurationValue_put = Type_Dictionary_Duration.put;
+
+const Type_Dictionary_Unknown = createServerTests(`/type/dictionary/unknown`, {
+  k1: 1,
+  k2: "hello",
+  k3: null,
+});
+Scenarios.Type_Dictionary_UnknownValue_get = Type_Dictionary_Unknown.get;
+Scenarios.Type_Dictionary_UnknownValue_put = Type_Dictionary_Unknown.put;
+
+const Type_Dictionary_Model = createServerTests(`/type/dictionary/model`, {
+  k1: { property: "hello" },
+  k2: { property: "world" },
+});
+Scenarios.Type_Dictionary_ModelValue_get = Type_Dictionary_Model.get;
+Scenarios.Type_Dictionary_ModelValue_put = Type_Dictionary_Model.put;
+
+const Type_Dictionary_Model_Recursive = createServerTests(`/type/dictionary/model/recursive`, {
+  k1: { property: "hello", children: {} },
+  k2: {
+    property: "world",
+    children: { "k2.1": { property: "inner world" } },
+  },
+});
+Scenarios.Type_Dictionary_RecursiveModelValue_get = Type_Dictionary_Model_Recursive.get;
+Scenarios.Type_Dictionary_RecursiveModelValue_put = Type_Dictionary_Model_Recursive.put;
+
+const Type_Dictionary_Nullable_Float = createServerTests(`/type/dictionary/nullable-float`, {
+  k1: 1.25,
+  k2: 0.5,
+  k3: null,
+});
+Scenarios.Type_Dictionary_NullableFloatValue_get = Type_Dictionary_Nullable_Float.get;
+Scenarios.Type_Dictionary_NullableFloatValue_put = Type_Dictionary_Nullable_Float.put;

package/specs/type/enum/extensible/main.tsp

@@ -0,0 +1,65 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@scenarioService("/type/enum/extensible")
+namespace Type.Enum.Extensible;
+
+@doc("Days of the week")
+union DaysOfWeekExtensibleEnum {
+  string,
+
+  @doc("Monday.")
+  Monday: "Monday",
+
+  @doc("Tuesday.")
+  Tuesday: "Tuesday",
+
+  @doc("Wednesday.")
+  Wednesday: "Wednesday",
+
+  @doc("Thursday.")
+  Thursday: "Thursday",
+
+  @doc("Friday.")
+  Friday: "Friday",
+
+  @doc("Saturday.")
+  Saturday: "Saturday",
+
+  @doc("Sunday.")
+  Sunday: "Sunday",
+}
+
+@route("/string")
+interface String {
+  @scenario
+  @scenarioDoc("Expect to handle a known value. Mock api will return 'Monday'")
+  @get
+  @route("/known-value")
+  getKnownValue(): {
+    @body body: DaysOfWeekExtensibleEnum;
+  };
+
+  @scenario
+  @scenarioDoc("Expect to handle an unknown value. Mock api will return 'Weekend'")
+  @get
+  @route("/unknown-value")
+  getUnknownValue(): {
+    @body body: DaysOfWeekExtensibleEnum;
+  };
+
+  @scenario
+  @scenarioDoc("Expect to send a known value. Mock api expect to receive 'Monday'")
+  @put
+  @route("/known-value")
+  putKnownValue(@body body: DaysOfWeekExtensibleEnum): void;
+
+  @scenario
+  @scenarioDoc("Expect to handle an unknown value. Mock api expect to receive 'Weekend'")
+  @put
+  @route("/unknown-value")
+  putUnknownValue(@body body: DaysOfWeekExtensibleEnum): void;
+}

package/specs/type/enum/extensible/mockapi.ts

@@ -0,0 +1,48 @@
+import { json, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+function createMockServerTests(uri: string, data: any) {
+  return {
+    get: passOnSuccess({
+      uri,
+      method: "get",
+      request: {},
+      response: {
+        status: 200,
+        body: json(data),
+      },
+      kind: "MockApiDefinition",
+    }),
+    put: passOnSuccess({
+      uri,
+      method: "put",
+      request: {
+        body: data,
+        headers: {
+          "Content-Type": "text/plain",
+        },
+      },
+      response: {
+        status: 204,
+      },
+      kind: "MockApiDefinition",
+    }),
+  };
+}
+
+const Type_Enum_Extensible_String_Known_Value = createMockServerTests(
+  `/type/enum/extensible/string/known-value`,
+  "Monday",
+);
+Scenarios.Type_Enum_Extensible_String_getKnownValue = Type_Enum_Extensible_String_Known_Value.get;
+Scenarios.Type_Enum_Extensible_String_putKnownValue = Type_Enum_Extensible_String_Known_Value.put;
+
+const Type_Enum_Extensible_String_UnKnown_Value = createMockServerTests(
+  `/type/enum/extensible/string/unknown-value`,
+  "Weekend",
+);
+Scenarios.Type_Enum_Extensible_String_getUnknownValue =
+  Type_Enum_Extensible_String_UnKnown_Value.get;
+Scenarios.Type_Enum_Extensible_String_putUnknownValue =
+  Type_Enum_Extensible_String_UnKnown_Value.put;

package/specs/type/enum/fixed/main.tsp

@@ -0,0 +1,60 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@scenarioService("/type/enum/fixed")
+namespace Type.Enum.Fixed;
+
+#suppress "@azure-tools/typespec-azure-core/use-extensible-enum" "For testing"
+@doc("Days of the week")
+enum DaysOfWeekEnum {
+  @doc("Monday.")
+  Monday,
+
+  @doc("Tuesday.")
+  Tuesday,
+
+  @doc("Wednesday.")
+  Wednesday,
+
+  @doc("Thursday.")
+  Thursday,
+
+  @doc("Friday.")
+  Friday,
+
+  @doc("Saturday.")
+  Saturday,
+
+  @doc("Sunday.")
+  Sunday,
+}
+
+@route("/string")
+interface String {
+  #suppress "@azure-tools/typespec-azure-core/use-standard-operations" "For testing"
+  @scenario
+  @scenarioDoc("Expect to handle a known value. Mock api will return 'Monday'")
+  @get
+  @route("/known-value")
+  @doc("getKnownValue")
+  getKnownValue(): DaysOfWeekEnum;
+
+  #suppress "@azure-tools/typespec-azure-core/use-standard-operations" "For testing"
+  @scenario
+  @scenarioDoc("Expect to send a known value. Mock api expect to receive 'Monday'")
+  @put
+  @route("/known-value")
+  @doc("putKnownValue")
+  putKnownValue(@body @doc("_") body: DaysOfWeekEnum): void;
+
+  #suppress "@azure-tools/typespec-azure-core/use-standard-operations" "For testing"
+  @scenario
+  @scenarioDoc("Expect to handle an unknown value. Mock api expect to receive 'Weekend'")
+  @put
+  @route("/unknown-value")
+  @doc("putUnknownValue")
+  putUnknownValue(@body @doc("_") body: DaysOfWeekEnum): void;
+}

package/specs/type/enum/fixed/mockapi.ts

@@ -0,0 +1,44 @@
+import { json, passOnCode, passOnSuccess, ScenarioMockApi } from "@typespec/spec-api";
+
+export const Scenarios: Record<string, ScenarioMockApi> = {};
+
+Scenarios.Type_Enum_Fixed_String_getKnownValue = passOnSuccess({
+  uri: "/type/enum/fixed/string/known-value",
+  method: "get",
+  request: {},
+  response: {
+    status: 200,
+    body: json("Monday"),
+  },
+  kind: "MockApiDefinition",
+});
+Scenarios.Type_Enum_Fixed_String_putKnownValue = passOnSuccess({
+  uri: "/type/enum/fixed/string/known-value",
+  method: "put",
+  request: {
+    body: "Monday",
+    headers: {
+      "Content-Type": "application/json",
+    },
+  },
+  response: {
+    status: 204,
+  },
+  kind: "MockApiDefinition",
+});
+
+Scenarios.Type_Enum_Fixed_String_putUnknownValue = passOnCode(500, {
+  uri: "/type/enum/fixed/string/unknown-value",
+  method: "put",
+  request: {
+    body: "Weekend",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    status: 500,
+  },
+  response: {
+    status: 500,
+  },
+  kind: "MockApiDefinition",
+});

package/specs/type/model/empty/main.tsp

@@ -0,0 +1,40 @@
+import "@typespec/http";
+import "@typespec/spector";
+
+using Http;
+using Spector;
+
+@doc("Illustrates usage of empty model used in operation's parameters and responses.")
+@scenarioService("/type/model/empty")
+namespace Type.Model.Empty;
+
+@doc("Empty model used in operation parameters")
+model EmptyInput {}
+
+@doc("Empty model used in operation return type")
+model EmptyOutput {}
+
+@doc("Empty model used in both parameter and return type")
+model EmptyInputOutput {}
+
+@scenario
+@scenarioDoc("Send a PUT request with the following body {}")
+@route("/alone")
+@put
+op putEmpty(@body input: EmptyInput): void;
+
+@scenario
+@scenarioDoc("Send a GET request which returns the following body {}")
+@route("/alone")
+@get
+op getEmpty(): {
+  @body body: EmptyOutput;
+};
+
+@scenario
+@scenarioDoc("Send a POST request with the following body {} which returns the same.")
+@route("/round-trip")
+@post
+op postRoundTripEmpty(@body body: EmptyInputOutput): {
+  @body body: EmptyInputOutput;
+};