chore(aws-restjson-server): generate with [email protected]

Author: trivikr

private/aws-restjson-server/src/models/models_0.ts

@@ -3355,6 +3355,38 @@ export namespace MalformedContentTypeWithGenericStringInput {
   };
 }
 
+/**
+ * @public
+ */
+export interface MalformedContentTypeWithoutBodyEmptyInputInput {
+  header?: string | undefined;
+}
+
+export namespace MalformedContentTypeWithoutBodyEmptyInputInput {
+  const memberValidators: {
+    header?: __MultiConstraintValidator<string>;
+  } = {};
+  /**
+   * @internal
+   */
+  export const validate = (obj: MalformedContentTypeWithoutBodyEmptyInputInput, path = ""): __ValidationFailure[] => {
+    function getMemberValidator<T extends keyof typeof memberValidators>(
+      member: T
+    ): NonNullable<(typeof memberValidators)[T]> {
+      if (memberValidators[member] === undefined) {
+        switch (member) {
+          case "header": {
+            memberValidators["header"] = new __NoOpValidator();
+            break;
+          }
+        }
+      }
+      return memberValidators[member]!;
+    }
+    return [...getMemberValidator("header").validate(obj.header, `${path}/header`)];
+  };
+}
+
 /**
  * @public
  */
@@ -5546,6 +5578,62 @@ export namespace QueryPrecedenceInput {
   };
 }
 
+/**
+ * @public
+ */
+export interface ResponseCodeHttpFallbackInputOutput {}
+
+export namespace ResponseCodeHttpFallbackInputOutput {
+  const memberValidators: {} = {};
+  /**
+   * @internal
+   */
+  export const validate = (obj: ResponseCodeHttpFallbackInputOutput, path = ""): __ValidationFailure[] => {
+    function getMemberValidator<T extends keyof typeof memberValidators>(
+      member: T
+    ): NonNullable<(typeof memberValidators)[T]> {
+      if (memberValidators[member] === undefined) {
+        switch (member) {
+        }
+      }
+      return memberValidators[member]!;
+    }
+    return [];
+  };
+}
+
+/**
+ * @public
+ */
+export interface ResponseCodeRequiredOutput {
+  responseCode: number | undefined;
+}
+
+export namespace ResponseCodeRequiredOutput {
+  const memberValidators: {
+    responseCode?: __MultiConstraintValidator<number>;
+  } = {};
+  /**
+   * @internal
+   */
+  export const validate = (obj: ResponseCodeRequiredOutput, path = ""): __ValidationFailure[] => {
+    function getMemberValidator<T extends keyof typeof memberValidators>(
+      member: T
+    ): NonNullable<(typeof memberValidators)[T]> {
+      if (memberValidators[member] === undefined) {
+        switch (member) {
+          case "responseCode": {
+            memberValidators["responseCode"] = new __CompositeValidator<number>([new __RequiredValidator()]);
+            break;
+          }
+        }
+      }
+      return memberValidators[member]!;
+    }
+    return [...getMemberValidator("responseCode").validate(obj.responseCode, `${path}/responseCode`)];
+  };
+}
+
 /**
  * @public
  */

private/aws-restjson-server/src/protocols/Aws_restJson1.ts

@@ -213,6 +213,10 @@ import {
   MalformedContentTypeWithoutBodyServerInput,
   MalformedContentTypeWithoutBodyServerOutput,
 } from "../server/operations/MalformedContentTypeWithoutBody";
+import {
+  MalformedContentTypeWithoutBodyEmptyInputServerInput,
+  MalformedContentTypeWithoutBodyEmptyInputServerOutput,
+} from "../server/operations/MalformedContentTypeWithoutBodyEmptyInput";
 import {
   MalformedContentTypeWithPayloadServerInput,
   MalformedContentTypeWithPayloadServerOutput,
@@ -324,6 +328,14 @@ import {
 } from "../server/operations/QueryParamsAsStringListMap";
 import { QueryPrecedenceServerInput, QueryPrecedenceServerOutput } from "../server/operations/QueryPrecedence";
 import { RecursiveShapesServerInput, RecursiveShapesServerOutput } from "../server/operations/RecursiveShapes";
+import {
+  ResponseCodeHttpFallbackServerInput,
+  ResponseCodeHttpFallbackServerOutput,
+} from "../server/operations/ResponseCodeHttpFallback";
+import {
+  ResponseCodeRequiredServerInput,
+  ResponseCodeRequiredServerOutput,
+} from "../server/operations/ResponseCodeRequired";
 import {
   SimpleScalarPropertiesServerInput,
   SimpleScalarPropertiesServerOutput,
@@ -2032,6 +2044,33 @@ export const deserializeMalformedContentTypeWithoutBodyRequest = async (
   return contents;
 };
 
+export const deserializeMalformedContentTypeWithoutBodyEmptyInputRequest = async (
+  output: __HttpRequest,
+  context: __SerdeContext
+): Promise<MalformedContentTypeWithoutBodyEmptyInputServerInput> => {
+  const contentTypeHeaderKey: string | undefined = Object.keys(output.headers).find(
+    (key) => key.toLowerCase() === "content-type"
+  );
+  if (contentTypeHeaderKey != null) {
+    const contentType = output.headers[contentTypeHeaderKey];
+    if (contentType !== undefined && contentType !== "application/json") {
+      throw new __UnsupportedMediaTypeException();
+    }
+  }
+  const acceptHeaderKey: string | undefined = Object.keys(output.headers).find((key) => key.toLowerCase() === "accept");
+  if (acceptHeaderKey != null) {
+    const accept = output.headers[acceptHeaderKey];
+    if (!__acceptMatches(accept, "application/json")) {
+      throw new __NotAcceptableException();
+    }
+  }
+  const contents: any = map({
+    [_h]: [, output.headers[_h]],
+  });
+  await collectBody(output.body, context);
+  return contents;
+};
+
 export const deserializeMalformedContentTypeWithPayloadRequest = async (
   output: __HttpRequest,
   context: __SerdeContext
@@ -3438,6 +3477,56 @@ export const deserializeRecursiveShapesRequest = async (
   return contents;
 };
 
+export const deserializeResponseCodeHttpFallbackRequest = async (
+  output: __HttpRequest,
+  context: __SerdeContext
+): Promise<ResponseCodeHttpFallbackServerInput> => {
+  const contentTypeHeaderKey: string | undefined = Object.keys(output.headers).find(
+    (key) => key.toLowerCase() === "content-type"
+  );
+  if (contentTypeHeaderKey != null) {
+    const contentType = output.headers[contentTypeHeaderKey];
+    if (contentType !== undefined && contentType !== "application/json") {
+      throw new __UnsupportedMediaTypeException();
+    }
+  }
+  const acceptHeaderKey: string | undefined = Object.keys(output.headers).find((key) => key.toLowerCase() === "accept");
+  if (acceptHeaderKey != null) {
+    const accept = output.headers[acceptHeaderKey];
+    if (!__acceptMatches(accept, "application/json")) {
+      throw new __NotAcceptableException();
+    }
+  }
+  const contents: any = map({});
+  await collectBody(output.body, context);
+  return contents;
+};
+
+export const deserializeResponseCodeRequiredRequest = async (
+  output: __HttpRequest,
+  context: __SerdeContext
+): Promise<ResponseCodeRequiredServerInput> => {
+  const contentTypeHeaderKey: string | undefined = Object.keys(output.headers).find(
+    (key) => key.toLowerCase() === "content-type"
+  );
+  if (contentTypeHeaderKey != null) {
+    const contentType = output.headers[contentTypeHeaderKey];
+    if (contentType !== undefined) {
+      throw new __UnsupportedMediaTypeException();
+    }
+  }
+  const acceptHeaderKey: string | undefined = Object.keys(output.headers).find((key) => key.toLowerCase() === "accept");
+  if (acceptHeaderKey != null) {
+    const accept = output.headers[acceptHeaderKey];
+    if (!__acceptMatches(accept, "application/json")) {
+      throw new __NotAcceptableException();
+    }
+  }
+  const contents: any = map({});
+  await collectBody(output.body, context);
+  return contents;
+};
+
 export const deserializeSimpleScalarPropertiesRequest = async (
   output: __HttpRequest,
   context: __SerdeContext
@@ -5701,6 +5790,40 @@ export const serializeMalformedContentTypeWithoutBodyResponse = async (
   });
 };
 
+export const serializeMalformedContentTypeWithoutBodyEmptyInputResponse = async (
+  input: MalformedContentTypeWithoutBodyEmptyInputServerOutput,
+  ctx: ServerSerdeContext
+): Promise<__HttpResponse> => {
+  const context: __SerdeContext = {
+    ...ctx,
+    endpoint: () =>
+      Promise.resolve({
+        protocol: "",
+        hostname: "",
+        path: "",
+      }),
+  };
+  const statusCode = 200;
+  let headers: any = map({}, isSerializableHeaderValue, {});
+  let body: any;
+  if (
+    body &&
+    Object.keys(headers)
+      .map((str) => str.toLowerCase())
+      .indexOf("content-length") === -1
+  ) {
+    const length = calculateBodyLength(body);
+    if (length !== undefined) {
+      headers = { ...headers, "content-length": String(length) };
+    }
+  }
+  return new __HttpResponse({
+    headers,
+    body,
+    statusCode,
+  });
+};
+
 export const serializeMalformedContentTypeWithPayloadResponse = async (
   input: MalformedContentTypeWithPayloadServerOutput,
   ctx: ServerSerdeContext
@@ -7113,6 +7236,83 @@ export const serializeRecursiveShapesResponse = async (
   });
 };
 
+export const serializeResponseCodeHttpFallbackResponse = async (
+  input: ResponseCodeHttpFallbackServerOutput,
+  ctx: ServerSerdeContext
+): Promise<__HttpResponse> => {
+  const context: __SerdeContext = {
+    ...ctx,
+    endpoint: () =>
+      Promise.resolve({
+        protocol: "",
+        hostname: "",
+        path: "",
+      }),
+  };
+  const statusCode = 201;
+  let headers: any = map({}, isSerializableHeaderValue, {
+    "content-type": "application/json",
+  });
+  let body: any;
+  body = "{}";
+  if (
+    body &&
+    Object.keys(headers)
+      .map((str) => str.toLowerCase())
+      .indexOf("content-length") === -1
+  ) {
+    const length = calculateBodyLength(body);
+    if (length !== undefined) {
+      headers = { ...headers, "content-length": String(length) };
+    }
+  }
+  return new __HttpResponse({
+    headers,
+    body,
+    statusCode,
+  });
+};
+
+export const serializeResponseCodeRequiredResponse = async (
+  input: ResponseCodeRequiredServerOutput,
+  ctx: ServerSerdeContext
+): Promise<__HttpResponse> => {
+  const context: __SerdeContext = {
+    ...ctx,
+    endpoint: () =>
+      Promise.resolve({
+        protocol: "",
+        hostname: "",
+        path: "",
+      }),
+  };
+  let statusCode = 200;
+  if (input.responseCode !== undefined) {
+    statusCode = input.responseCode;
+  }
+  let headers: any = map({}, isSerializableHeaderValue, {
+    "content-type": "application/json",
+  });
+  let body: any;
+  body = "{}";
+  if (
+    body &&
+    Object.keys(headers)
+      .map((str) => str.toLowerCase())
+      .indexOf("content-length") === -1
+  ) {
+    const length = calculateBodyLength(body);
+    if (length !== undefined) {
+      headers = { ...headers, "content-length": String(length) };
+    }
+  }
+  return new __HttpResponse({
+    headers,
+    body,
+    statusCode,
+  });
+};
+
 export const serializeSimpleScalarPropertiesResponse = async (
   input: SimpleScalarPropertiesServerOutput,
   ctx: ServerSerdeContext
@@ -9169,6 +9369,7 @@ const _f = "foo";
 const _fIH = "floatInHeader";
 const _fl = "floatinheader";
 const _g = "greeting";
+const _h = "header";
 const _hB = "headerByte";
 const _hBL = "headerBooleanList";
 const _hD = "headerDouble";