diff --git a/packages/middleware-stack/src/MiddlewareStack.spec.ts b/packages/middleware-stack/src/MiddlewareStack.spec.ts
index b6f9397e5611..3e94a1d93010 100644
--- a/packages/middleware-stack/src/MiddlewareStack.spec.ts
+++ b/packages/middleware-stack/src/MiddlewareStack.spec.ts
@@ -11,7 +11,7 @@ import {
   Pluggable,
 } from "@aws-sdk/types";
 
-import { MiddlewareStack } from "./MiddlewareStack";
+import { constructStack } from "./MiddlewareStack";
 
 type input = Array<string>;
 type output = object;
@@ -29,7 +29,7 @@ function getConcatMiddleware(message: string): MiddlewareType<input, output> {
 
 describe("MiddlewareStack", () => {
   it("should resolve the stack into a composed handler", async () => {
-    const stack = new MiddlewareStack<input, output>();
+    const stack = constructStack<input, output>();
     const secondMW = getConcatMiddleware("second") as InitializeMiddleware<input, output>;
     stack.add(secondMW, { name: "second" });
     stack.addRelativeTo(getConcatMiddleware("first") as InitializeMiddleware<input, output>, {
@@ -75,7 +75,7 @@ describe("MiddlewareStack", () => {
   });
 
   it("should allow adding middleware relatively", async () => {
-    const stack = new MiddlewareStack<input, output>();
+    const stack = constructStack<input, output>();
     type MW = InitializeMiddleware<input, output>;
     stack.addRelativeTo(getConcatMiddleware("H") as MW, {
       name: "H",
@@ -145,7 +145,7 @@ describe("MiddlewareStack", () => {
   });
 
   it("should allow cloning", async () => {
-    const stack = new MiddlewareStack<input, output>();
+    const stack = constructStack<input, output>();
     const secondMiddleware = getConcatMiddleware("second") as InitializeMiddleware<input, output>;
     stack.add(secondMiddleware);
     stack.add(getConcatMiddleware("first") as InitializeMiddleware<input, output>, {
@@ -174,14 +174,14 @@ describe("MiddlewareStack", () => {
   });
 
   it("should allow combining stacks", async () => {
-    const stack = new MiddlewareStack<input, output>();
+    const stack = constructStack<input, output>();
     stack.add(getConcatMiddleware("first") as InitializeMiddleware<input, output>);
     stack.add(getConcatMiddleware("second") as InitializeMiddleware<input, output>, {
       name: "second",
       priority: "low",
     });
 
-    const secondStack = new MiddlewareStack<input, output>();
+    const secondStack = constructStack<input, output>();
     secondStack.add(getConcatMiddleware("fourth") as FinalizeRequestMiddleware<input, output>, {
       step: "build",
       priority: "low",
@@ -209,7 +209,7 @@ describe("MiddlewareStack", () => {
   });
 
   it("should allow the removal of middleware by constructor identity", async () => {
-    const stack = new MiddlewareStack<input, output>();
+    const stack = constructStack<input, output>();
     stack.add(getConcatMiddleware("don't remove me") as InitializeMiddleware<input, output>, { name: "notRemove" });
     stack.addRelativeTo(getConcatMiddleware("remove me!") as InitializeMiddleware<input, output>, {
       relation: "after",
@@ -231,7 +231,7 @@ describe("MiddlewareStack", () => {
   });
 
   it("should allow the removal of middleware by tag", async () => {
-    const stack = new MiddlewareStack<input, output>();
+    const stack = constructStack<input, output>();
     stack.add(getConcatMiddleware("not removed") as InitializeMiddleware<input, output>, {
       name: "not removed",
       tags: ["foo", "bar"],
@@ -256,7 +256,7 @@ describe("MiddlewareStack", () => {
   });
 
   it("should apply customizations from pluggables", async () => {
-    const stack = new MiddlewareStack<input, output>();
+    const stack = constructStack<input, output>();
     const plugin: Pluggable<input, output> = {
       applyToStack: (stack) => {
         stack.addRelativeTo(getConcatMiddleware("second") as InitializeMiddleware<input, output>, {
diff --git a/packages/middleware-stack/src/MiddlewareStack.ts b/packages/middleware-stack/src/MiddlewareStack.ts
index d27784f44ac5..65484e429fba 100644
--- a/packages/middleware-stack/src/MiddlewareStack.ts
+++ b/packages/middleware-stack/src/MiddlewareStack.ts
@@ -1,24 +1,14 @@
 import {
   AbsoluteLocation,
-  BuildHandlerOptions,
-  BuildMiddleware,
   DeserializeHandler,
-  DeserializeHandlerOptions,
-  DeserializeMiddleware,
-  FinalizeRequestHandlerOptions,
-  FinalizeRequestMiddleware,
   Handler,
   HandlerExecutionContext,
   HandlerOptions,
-  InitializeHandlerOptions,
-  InitializeMiddleware,
   MiddlewareStack as IMiddlewareStack,
   MiddlewareType,
   Pluggable,
   Priority,
   RelativeLocation,
-  SerializeHandlerOptions,
-  SerializeMiddleware,
   Step,
 } from "@aws-sdk/types";
 
@@ -32,200 +22,76 @@ import {
   RelativeMiddlewareEntry,
 } from "./types";
 
-export interface MiddlewareStack<Input extends object, Output extends object> extends IMiddlewareStack<Input, Output> {}
-
-export class MiddlewareStack<Input extends object, Output extends object> {
-  private readonly absoluteEntries: Array<MiddlewareEntry<Input, Output>> = [];
-  private readonly relativeEntries: Array<RelativeMiddlewareEntry<Input, Output>> = [];
-  private entriesNameMap: {
+export function constructStack<Input extends object, Output extends object>(): IMiddlewareStack<Input, Output> {
+  const absoluteEntries: Array<MiddlewareEntry<Input, Output>> = [];
+  const relativeEntries: Array<RelativeMiddlewareEntry<Input, Output>> = [];
+  const entriesNameMap: {
     [middlewareName: string]: MiddlewareEntry<Input, Output> | RelativeMiddlewareEntry<Input, Output>;
   } = {};
 
-  add(middleware: InitializeMiddleware<Input, Output>, options?: InitializeHandlerOptions & AbsoluteLocation): void;
-
-  add(middleware: SerializeMiddleware<Input, Output>, options: SerializeHandlerOptions & AbsoluteLocation): void;
-
-  add(middleware: BuildMiddleware<Input, Output>, options: BuildHandlerOptions & AbsoluteLocation): void;
-
-  add(
-    middleware: FinalizeRequestMiddleware<Input, Output>,
-    options: FinalizeRequestHandlerOptions & AbsoluteLocation
-  ): void;
-
-  add(middleware: DeserializeMiddleware<Input, Output>, options: DeserializeHandlerOptions & AbsoluteLocation): void;
-
-  add(middleware: MiddlewareType<Input, Output>, options: HandlerOptions & AbsoluteLocation = {}): void {
-    const { name, step = "initialize", tags, priority = "normal" } = options;
-    const entry: MiddlewareEntry<Input, Output> = {
-      name,
-      step,
-      tags,
-      priority,
-      middleware,
-    };
-    if (name) {
-      if (Object.prototype.hasOwnProperty.call(this.entriesNameMap, name)) {
-        throw new Error(`Duplicated middleware name '${name}'`);
-      }
-      this.entriesNameMap[name] = entry;
-    }
-    this.absoluteEntries.push(entry);
-  }
-
-  addRelativeTo(
-    middleware: InitializeMiddleware<Input, Output>,
-    options: InitializeHandlerOptions & RelativeLocation<Input, Output>
-  ): void;
-
-  addRelativeTo(
-    middleware: SerializeMiddleware<Input, Output>,
-    options: SerializeHandlerOptions & RelativeLocation<Input, Output>
-  ): void;
-
-  addRelativeTo(
-    middleware: BuildMiddleware<Input, Output>,
-    options: BuildHandlerOptions & RelativeLocation<Input, Output>
-  ): void;
-
-  addRelativeTo(
-    middleware: FinalizeRequestMiddleware<Input, Output>,
-    options: FinalizeRequestHandlerOptions & RelativeLocation<Input, Output>
-  ): void;
-
-  addRelativeTo(
-    middleware: DeserializeMiddleware<Input, Output>,
-    options: DeserializeHandlerOptions & RelativeLocation<Input, Output>
-  ): void;
-
-  addRelativeTo(
-    middleware: MiddlewareType<Input, Output>,
-    options: HandlerOptions & RelativeLocation<Input, Output>
-  ): void {
-    const { step = "initialize", name, tags, relation, toMiddleware } = options;
-    const entry: RelativeMiddlewareEntry<Input, Output> = {
-      middleware,
-      step,
-      name,
-      tags,
-      next: relation === "before" ? toMiddleware : undefined,
-      prev: relation === "after" ? toMiddleware : undefined,
-    };
-    if (name) {
-      if (Object.prototype.hasOwnProperty.call(this.entriesNameMap, name)) {
-        throw new Error(`Duplicated middleware name '${name}'`);
-      }
-      this.entriesNameMap[name] = entry;
-    }
-    this.relativeEntries.push(entry);
-  }
-
-  private sort(
+  const sort = (
     entries: Array<MiddlewareEntry<Input, Output> | NormalizedRelativeEntry<Input, Output>>
-  ): Array<MiddlewareEntry<Input, Output> | NormalizedRelativeEntry<Input, Output>> {
+  ): Array<MiddlewareEntry<Input, Output> | NormalizedRelativeEntry<Input, Output>> =>
     //reverse before sorting so that middleware of same step will execute in
     //the order of being added
-    return entries.sort(
+    entries.sort(
       (a, b) =>
         stepWeights[b.step] - stepWeights[a.step] ||
         priorityWeights[b.priority || "normal"] - priorityWeights[a.priority || "normal"]
     );
-  }
-
-  clone(): IMiddlewareStack<Input, Output> {
-    const clone = new MiddlewareStack<Input, Output>();
-    clone.absoluteEntries.push(...this.absoluteEntries);
-    clone.relativeEntries.push(...this.relativeEntries);
-    clone.entriesNameMap = { ...this.entriesNameMap };
-    return clone;
-  }
 
-  concat<InputType extends Input, OutputType extends Output>(
-    from: IMiddlewareStack<InputType, OutputType>
-  ): MiddlewareStack<InputType, OutputType> {
-    const clone = new MiddlewareStack<InputType, OutputType>();
-    clone.entriesNameMap = { ...(this.entriesNameMap as any) };
-    // IMiddlewareStack interface doesn't contain private members variables
-    // like `entriesNameMap`, but in fact the function expects `MiddlewareStack`
-    // class instance. So here we cast it.
-    const _from = from as MiddlewareStack<InputType, OutputType>;
-    for (const name in _from.entriesNameMap) {
-      if (clone.entriesNameMap[name]) {
-        throw new Error(`Duplicated middleware name '${name}'`);
-      }
-      clone.entriesNameMap[name] = _from.entriesNameMap[name];
-    }
-    clone.absoluteEntries.push(...(this.absoluteEntries as any), ..._from.absoluteEntries);
-    clone.relativeEntries.push(...(this.relativeEntries as any), ..._from.relativeEntries);
-    return clone;
-  }
-
-  remove(toRemove: MiddlewareType<Input, Output> | string): boolean {
-    if (typeof toRemove === "string") return this.removeByName(toRemove);
-    else return this.removeByReference(toRemove);
-  }
-
-  private removeByName(toRemove: string): boolean {
-    for (let i = this.absoluteEntries.length - 1; i >= 0; i--) {
-      if (this.absoluteEntries[i].name && this.absoluteEntries[i].name === toRemove) {
-        this.absoluteEntries.splice(i, 1);
-        delete this.entriesNameMap[toRemove];
+  const removeByName = (toRemove: string): boolean => {
+    for (let i = absoluteEntries.length - 1; i >= 0; i--) {
+      if (absoluteEntries[i].name && absoluteEntries[i].name === toRemove) {
+        absoluteEntries.splice(i, 1);
+        delete entriesNameMap[toRemove];
         return true;
       }
     }
-    for (let i = this.relativeEntries.length - 1; i >= 0; i--) {
-      if (this.relativeEntries[i].name && this.relativeEntries[i].name === toRemove) {
-        this.relativeEntries.splice(i, 1);
-        delete this.entriesNameMap[toRemove];
+    for (let i = relativeEntries.length - 1; i >= 0; i--) {
+      if (relativeEntries[i].name && relativeEntries[i].name === toRemove) {
+        relativeEntries.splice(i, 1);
+        delete entriesNameMap[toRemove];
         return true;
       }
     }
     return false;
-  }
+  };
 
-  private removeByReference(toRemove: MiddlewareType<Input, Output>): boolean {
-    for (let i = this.absoluteEntries.length - 1; i >= 0; i--) {
-      if (this.absoluteEntries[i].middleware === toRemove) {
-        const { name } = this.absoluteEntries[i];
-        if (name) delete this.entriesNameMap[name];
-        this.absoluteEntries.splice(i, 1);
+  const removeByReference = (toRemove: MiddlewareType<Input, Output>): boolean => {
+    for (let i = absoluteEntries.length - 1; i >= 0; i--) {
+      if (absoluteEntries[i].middleware === toRemove) {
+        const { name } = absoluteEntries[i];
+        if (name) delete entriesNameMap[name];
+        absoluteEntries.splice(i, 1);
         return true;
       }
     }
-    for (let i = this.relativeEntries.length - 1; i >= 0; i--) {
-      if (this.relativeEntries[i].middleware === toRemove) {
-        const { name } = this.relativeEntries[i];
-        if (name) delete this.entriesNameMap[name];
-        this.relativeEntries.splice(i, 1);
+    for (let i = relativeEntries.length - 1; i >= 0; i--) {
+      if (relativeEntries[i].middleware === toRemove) {
+        const { name } = relativeEntries[i];
+        if (name) delete entriesNameMap[name];
+        relativeEntries.splice(i, 1);
         return true;
       }
     }
     return false;
-  }
-
-  removeByTag(toRemove: string): boolean {
-    let removed = false;
-    for (let i = this.absoluteEntries.length - 1; i >= 0; i--) {
-      const { tags, name } = this.absoluteEntries[i];
-      if (tags && tags.indexOf(toRemove) > -1) {
-        this.absoluteEntries.splice(i, 1);
-        if (name) delete this.entriesNameMap[name];
-        removed = true;
-      }
-    }
-    for (let i = this.relativeEntries.length - 1; i >= 0; i--) {
-      const { tags, name } = this.relativeEntries[i];
-      if (tags && tags.indexOf(toRemove) > -1) {
-        this.relativeEntries.splice(i, 1);
-        if (name) delete this.entriesNameMap[name];
-        removed = true;
-      }
-    }
-    return removed;
-  }
+  };
 
-  use(plugin: Pluggable<Input, Output>) {
-    plugin.applyToStack(this);
-  }
+  const cloneTo = <InputType extends Input, OutputType extends Output>(
+    toStack: IMiddlewareStack<InputType, OutputType>
+  ): IMiddlewareStack<InputType, OutputType> => {
+    const clone = toStack || constructStack<InputType, OutputType>();
+    absoluteEntries.forEach((entry) => {
+      //@ts-ignore
+      clone.add(entry.middleware, { ...entry });
+    });
+    relativeEntries.forEach((entry) => {
+      //@ts-ignore
+      clone.addRelativeTo(entry.middleware, { ...entry });
+    });
+    return clone;
+  };
 
   /**
    * Resolve relative middleware entries to multiple double linked lists
@@ -240,14 +106,14 @@ export class MiddlewareStack<Input extends object, Output extends object> {
    *
    * The 2 types of linked list will return as a tuple
    */
-  private normalizeRelativeEntries(): NormalizingEntryResult<Input, Output> {
-    const absoluteMiddlewareNamesMap = this.absoluteEntries
+  const normalizeRelativeEntries = (): NormalizingEntryResult<Input, Output> => {
+    const absoluteMiddlewareNamesMap = absoluteEntries
       .filter((entry) => entry.name)
       .reduce((accumulator, entry) => {
         accumulator[entry.name!] = entry;
         return accumulator;
       }, {} as NamedMiddlewareEntriesMap<Input, Output>);
-    const normalized = this.relativeEntries.map(
+    const normalized = relativeEntries.map(
       (entry) =>
         ({
           ...entry,
@@ -264,8 +130,8 @@ export class MiddlewareStack<Input extends object, Output extends object> {
       }, {} as NamedRelativeEntriesMap<Input, Output>);
 
     const anchors: RelativeMiddlewareAnchor<Input, Output> = {};
-    for (let i = 0; i < this.relativeEntries.length; i++) {
-      const { prev, next } = this.relativeEntries[i];
+    for (let i = 0; i < relativeEntries.length; i++) {
+      const { prev, next } = relativeEntries[i];
       const resolvedCurr = normalized[i];
       //either prev or next is set
       if (prev) {
@@ -323,7 +189,7 @@ export class MiddlewareStack<Input extends object, Output extends object> {
       }
     }
     return [orphanedRelativeEntries, anchors];
-  }
+  };
 
   /**
    * Get a final list of middleware in the order of being executed in the resolved handler.
@@ -334,11 +200,11 @@ export class MiddlewareStack<Input extends object, Output extends object> {
    * 2. if `toMiddleware` doesn't exist in the specific `step`, the middleware will be appended
    *     to specific `step` with priority of `normal`
    */
-  private getMiddlewareList(): Array<MiddlewareType<Input, Output>> {
+  const getMiddlewareList = (): Array<MiddlewareType<Input, Output>> => {
     const middlewareList: Array<MiddlewareType<Input, Output>> = [];
-    const [orphanedRelativeEntries, anchors] = this.normalizeRelativeEntries();
-    let entryList = [...this.absoluteEntries, ...orphanedRelativeEntries];
-    entryList = this.sort(entryList);
+    const [orphanedRelativeEntries, anchors] = normalizeRelativeEntries();
+    let entryList = [...absoluteEntries, ...orphanedRelativeEntries];
+    entryList = sort(entryList);
     for (const entry of entryList) {
       const defaultAnchorValue = { prev: undefined, next: undefined };
       const { prev, next } = entry.name ? anchors[entry.name] || defaultAnchorValue : defaultAnchorValue;
@@ -364,18 +230,89 @@ export class MiddlewareStack<Input extends object, Output extends object> {
       }
     }
     return middlewareList.reverse();
-  }
-
-  resolve<InputType extends Input, OutputType extends Output>(
-    handler: DeserializeHandler<InputType, OutputType>,
-    context: HandlerExecutionContext
-  ): Handler<InputType, OutputType> {
-    for (const middleware of this.getMiddlewareList()) {
-      handler = middleware(handler as Handler<Input, OutputType>, context) as any;
-    }
+  };
 
-    return handler as Handler<InputType, OutputType>;
-  }
+  const stack = {
+    add: (middleware: MiddlewareType<Input, Output>, options: HandlerOptions & AbsoluteLocation = {}) => {
+      const { name, step = "initialize", tags, priority = "normal" } = options;
+      const entry: MiddlewareEntry<Input, Output> = {
+        name,
+        step,
+        tags,
+        priority,
+        middleware,
+      };
+      if (name) {
+        if (Object.prototype.hasOwnProperty.call(entriesNameMap, name)) {
+          throw new Error(`Duplicated middleware name '${name}'`);
+        }
+        entriesNameMap[name] = entry;
+      }
+      absoluteEntries.push(entry);
+    },
+    addRelativeTo: (
+      middleware: MiddlewareType<Input, Output>,
+      options: HandlerOptions & RelativeLocation<Input, Output>
+    ) => {
+      const { step = "initialize", name, tags, relation, toMiddleware } = options;
+      const entry: RelativeMiddlewareEntry<Input, Output> = {
+        middleware,
+        step,
+        name,
+        tags,
+        next: relation === "before" ? toMiddleware : undefined,
+        prev: relation === "after" ? toMiddleware : undefined,
+      };
+      if (name) {
+        if (Object.prototype.hasOwnProperty.call(entriesNameMap, name)) {
+          throw new Error(`Duplicated middleware name '${name}'`);
+        }
+        entriesNameMap[name] = entry;
+      }
+      relativeEntries.push(entry);
+    },
+    clone: (): IMiddlewareStack<Input, Output> => cloneTo(constructStack<Input, Output>()),
+    use: (plugin: Pluggable<Input, Output>) => {
+      plugin.applyToStack(stack);
+    },
+    remove: (toRemove: MiddlewareType<Input, Output> | string): boolean => {
+      if (typeof toRemove === "string") return removeByName(toRemove);
+      else return removeByReference(toRemove);
+    },
+    removeByTag: (toRemove: string): boolean => {
+      let removed = false;
+      for (let i = absoluteEntries.length - 1; i >= 0; i--) {
+        const { tags, name } = absoluteEntries[i];
+        if (tags && tags.indexOf(toRemove) > -1) {
+          absoluteEntries.splice(i, 1);
+          if (name) delete entriesNameMap[name];
+          removed = true;
+        }
+      }
+      for (let i = relativeEntries.length - 1; i >= 0; i--) {
+        const { tags, name } = relativeEntries[i];
+        if (tags && tags.indexOf(toRemove) > -1) {
+          relativeEntries.splice(i, 1);
+          if (name) delete entriesNameMap[name];
+          removed = true;
+        }
+      }
+      return removed;
+    },
+    concat: <InputType extends Input, OutputType extends Output>(
+      from: IMiddlewareStack<InputType, OutputType>
+    ): IMiddlewareStack<InputType, OutputType> => cloneTo(from.clone()),
+    resolve: <InputType extends Input, OutputType extends Output>(
+      handler: DeserializeHandler<InputType, OutputType>,
+      context: HandlerExecutionContext
+    ): Handler<InputType, OutputType> => {
+      for (const middleware of getMiddlewareList()) {
+        handler = middleware(handler as Handler<Input, OutputType>, context) as any;
+      }
+      return handler as Handler<InputType, OutputType>;
+    },
+  };
+  return stack;
 }
 
 const stepWeights: { [key in Step]: number } = {
diff --git a/packages/smithy-client/src/client.ts b/packages/smithy-client/src/client.ts
index b2ff43dc83b2..5112a91b3290 100644
--- a/packages/smithy-client/src/client.ts
+++ b/packages/smithy-client/src/client.ts
@@ -1,4 +1,4 @@
-import { MiddlewareStack } from "@aws-sdk/middleware-stack";
+import { constructStack } from "@aws-sdk/middleware-stack";
 import { Client as IClient, Command, MetadataBearer, RequestHandler } from "@aws-sdk/types";
 
 export interface SmithyConfiguration<HandlerOptions> {
@@ -14,7 +14,7 @@ export class Client<
   ClientOutput extends MetadataBearer,
   ResolvedClientConfiguration extends SmithyResolvedConfiguration<HandlerOptions>
 > implements IClient<ClientInput, ClientOutput, ResolvedClientConfiguration> {
-  public middlewareStack = new MiddlewareStack<ClientInput, ClientOutput>();
+  public middlewareStack = constructStack<ClientInput, ClientOutput>();
   readonly config: ResolvedClientConfiguration;
   constructor(config: ResolvedClientConfiguration) {
     this.config = config;
diff --git a/packages/smithy-client/src/command.ts b/packages/smithy-client/src/command.ts
index 9295f6192887..f7065e4f2485 100644
--- a/packages/smithy-client/src/command.ts
+++ b/packages/smithy-client/src/command.ts
@@ -1,4 +1,4 @@
-import { MiddlewareStack } from "@aws-sdk/middleware-stack";
+import { constructStack } from "@aws-sdk/middleware-stack";
 import { Command as ICommand, Handler, MetadataBearer, MiddlewareStack as IMiddlewareStack } from "@aws-sdk/types";
 
 export abstract class Command<
@@ -9,9 +9,9 @@ export abstract class Command<
   ClientOutput extends MetadataBearer = any
 > implements ICommand<ClientInput, Input, ClientOutput, Output, ResolvedClientConfiguration> {
   abstract input: Input;
-  readonly middlewareStack: IMiddlewareStack<Input, Output> = new MiddlewareStack<Input, Output>();
+  readonly middlewareStack: IMiddlewareStack<Input, Output> = constructStack<Input, Output>();
   abstract resolveMiddleware(
-    stack: MiddlewareStack<ClientInput, ClientOutput>,
+    stack: IMiddlewareStack<ClientInput, ClientOutput>,
     configuration: ResolvedClientConfiguration,
     options: any
   ): Handler<Input, Output>;
diff --git a/packages/util-create-request/src/foo.fixture.ts b/packages/util-create-request/src/foo.fixture.ts
index bc58cb448b48..8361f7b86ac9 100644
--- a/packages/util-create-request/src/foo.fixture.ts
+++ b/packages/util-create-request/src/foo.fixture.ts
@@ -1,7 +1,7 @@
-import { MiddlewareStack } from "@aws-sdk/middleware-stack";
+import { constructStack } from "@aws-sdk/middleware-stack";
 import { HttpRequest } from "@aws-sdk/protocol-http";
 import { Client, Command } from "@aws-sdk/smithy-client";
-import { MetadataBearer } from "@aws-sdk/types";
+import { MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 
 export interface OperationInput {
   String: string;
@@ -22,14 +22,14 @@ const input: OperationInput = { String: "input" };
 
 export const fooClient: Client<any, InputTypesUnion, OutputTypesUnion, any> = {
   config: {},
-  middlewareStack: new MiddlewareStack<InputTypesUnion, OutputTypesUnion>(),
+  middlewareStack: constructStack<InputTypesUnion, OutputTypesUnion>(),
   send: (command: Command<InputTypesUnion, OutputTypesUnion, any, OperationInput, OperationOutput>) =>
     command.resolveMiddleware(this.middlewareStack, this.config, undefined)({ input }),
   destroy: () => {},
 };
 
 export const operationCommand: Command<InputTypesUnion, OutputTypesUnion, any, OperationInput, OperationOutput> = {
-  middlewareStack: new MiddlewareStack<object, OutputTypesUnion>(),
+  middlewareStack: constructStack<object, OutputTypesUnion>(),
   input: {} as any,
   resolveMiddleware: (stack: MiddlewareStack<InputTypesUnion, OutputTypesUnion>) => {
     const concatStack = stack.concat(operationCommand.middlewareStack);