diff --git a/contrib/proxy_expr.h b/contrib/proxy_expr.h
index f5f828e..eac325e 100644
--- a/contrib/proxy_expr.h
+++ b/contrib/proxy_expr.h
@@ -16,7 +16,7 @@
  */
 
 // Create an expression using a foreign function call.
-inline WasmResult createExpression(StringView expr, uint32_t *token) {
+inline WasmResult createExpression(std::string_view expr, uint32_t *token) {
   std::string function = "expr_create";
   char *out = nullptr;
   size_t out_size = 0;
@@ -30,7 +30,7 @@ inline WasmResult createExpression(StringView expr, uint32_t *token) {
 }
 
 // Evaluate an expression using an expression token.
-inline Optional<WasmDataPtr> exprEvaluate(uint32_t token) {
+inline std::optional<WasmDataPtr> exprEvaluate(uint32_t token) {
   std::string function = "expr_evaluate";
   char *out = nullptr;
   size_t out_size = 0;
diff --git a/docs/wasm_filter.md b/docs/wasm_filter.md
index 470b44d..7c370a3 100644
--- a/docs/wasm_filter.md
+++ b/docs/wasm_filter.md
@@ -242,9 +242,9 @@ The following methods on context object are supported.
 ### httpCall
 
 ``` {.sourceCode .cpp}
-void httpCall(StringView cluster,
+void httpCall(std::string_view cluster,
               const HeaderStringPairs& request_headers,
-              StringView request_body,
+              std::string_view request_body,
               const HeaderStringPairs& request_trailers,
               uint32_t timeout_milliseconds,
               HttpCallCallback callback)
@@ -270,13 +270,13 @@ called when the HTTP request finishes.
 
 ``` {.sourceCode .cpp}
 template<typename Response>
-void grpcSimpleCall(StringView service,
-                    StringView service_name,
-                    StringView method_name,
+void grpcSimpleCall(std::string_view service,
+                    std::string_view service_name,
+                    std::string_view method_name,
                     const google::protobuf::MessageLite &request,
                     uint32_t timeout_milliseconds,
                     std::function<void(Response&& response)> success_callback,
-                    std::function<void(GrpcStatus status, StringView error_message)> failure_callback)
+                    std::function<void(GrpcStatus status, std::string_view error_message)> failure_callback)
 ```
 
 Makes a unary gRPC call to an upstream host.
@@ -304,9 +304,9 @@ invoked when gRPC call fails. *status* is the returned gRPC status code.
 
 ``` {.sourceCode .cpp}
 void grpcCallHandler(
-    StringView service,
-    StringView service_name,
-    StringView method_name,
+    std::string_view service,
+    std::string_view service_name,
+    std::string_view method_name,
     const google::protobuf::MessageLite &request,
     uint32_t timeout_milliseconds,
     std::unique_ptr<GrpcCallHandlerBase> handler)
@@ -323,9 +323,9 @@ target for callback and fine grained control on the call.
 ### grpcStreamHandler
 
 ``` {.sourceCode .cpp}
-void grpcStreamHandler(StringView service,
-                       StringView service_name,
-                       StringView method_name,
+void grpcStreamHandler(std::string_view service,
+                       std::string_view service_name,
+                       std::string_view method_name,
                        std::unique_ptr<GrpcStreamHandlerBase> handler)
 ```
 
@@ -367,7 +367,7 @@ Header API
 ### addRequestHeader
 
 ``` {.sourceCode .cpp}
-void addRequestHeader(StringView key, StringView value)
+void addRequestHeader(std::string_view key, StringView value)
 ```
 
 Adds a new request header with the key and value if header does not
@@ -378,7 +378,7 @@ only when called in
 ### replaceRequestHeader
 
 ``` {.sourceCode .cpp}
-void replaceRequestHeader(StringView key, StringView value)
+void replaceRequestHeader(std::string_view key, StringView value)
 ```
 
 Replaces the value of an existing request header with the given key, or
@@ -389,7 +389,7 @@ method is effective only when called in
 ### removeRequestHeader
 
 ``` {.sourceCode .cpp}
-void removeRequestHeader(StringView key)
+void removeRequestHeader(std::string_view key)
 ```
 
 Removes request header with the given key. No-op if the request header
@@ -410,7 +410,7 @@ effective only when called in
 ### getRequestHeader
 
 ``` {.sourceCode .cpp}
-WasmDataPtr getRequestHeader(StringView key)
+WasmDataPtr getRequestHeader(std::string_view key)
 ```
 
 Gets value of header with the given key. Returns empty string if header
@@ -437,7 +437,7 @@ contains header pairs data.
 ### addResponseHeader
 
 ``` {.sourceCode .cpp}
-void addResponseHeader(StringView key, StringView value)
+void addResponseHeader(std::string_view key, StringView value)
 ```
 
 Adds a new response header with the key and value if header does not
@@ -448,7 +448,7 @@ only when called in
 ### replaceResponseHeader
 
 ``` {.sourceCode .cpp}
-void replaceResponseHeader(StringView key, StringView value)
+void replaceResponseHeader(std::string_view key, StringView value)
 ```
 
 Replaces the value of an existing response header with the given key, or
@@ -459,7 +459,7 @@ This method is effective only when called in
 ### removeResponseHeader
 
 ``` {.sourceCode .cpp}
-void removeResponseHeader(StringView key)
+void removeResponseHeader(std::string_view key)
 ```
 
 Removes response header with the given key. No-op if the response header
@@ -480,7 +480,7 @@ is effective only when called in
 ### getResponseHeader
 
 ``` {.sourceCode .cpp}
-WasmDataPtr getResponseHeader(StringView key)
+WasmDataPtr getResponseHeader(std::string_view key)
 ```
 
 Gets value of header with the given key. Returns empty string if header
@@ -507,7 +507,7 @@ holds the header pairs.
 ### addRequestTrailer
 
 ``` {.sourceCode .cpp}
-void addRequestTrailer(StringView key, StringView value)
+void addRequestTrailer(std::string_view key, StringView value)
 ```
 
 Adds a new request trailer with the key and value if trailer does not
@@ -518,7 +518,7 @@ only when called in
 ### replaceRequestTrailer
 
 ``` {.sourceCode .cpp}
-void replaceRequestTrailer(StringView key, StringView value)
+void replaceRequestTrailer(std::string_view key, StringView value)
 ```
 
 Replaces the value of an existing request trailer with the given key, or
@@ -529,7 +529,7 @@ This method is effective only when called in
 ### removeRequestTrailer
 
 ``` {.sourceCode .cpp}
-void removeRequestTrailer(StringView key)
+void removeRequestTrailer(std::string_view key)
 ```
 
 Removes request trailer with the given key. No-op if the request trailer
@@ -550,7 +550,7 @@ effective only when called in
 ### getRequestTrailer
 
 ``` {.sourceCode .cpp}
-WasmDataPtr getRequestTrailer(StringView key)
+WasmDataPtr getRequestTrailer(std::string_view key)
 ```
 
 Gets value of trailer with the given key. Returns empty string if
@@ -575,7 +575,7 @@ holds the trailer pairs.
 ### addResponseTrailer
 
 ``` {.sourceCode .cpp}
-void addResponseTrailer(StringView key, StringView value)
+void addResponseTrailer(std::string_view key, StringView value)
 ```
 
 Adds a new response trailer with the key and value if trailer does not
@@ -586,7 +586,7 @@ only when called in
 ### replaceResponseTrailer
 
 ``` {.sourceCode .cpp}
-void replaceResponseTrailer(StringView key, StringView value)
+void replaceResponseTrailer(std::string_view key, StringView value)
 ```
 
 Replaces the value of an existing response trailer with the given key,
@@ -597,7 +597,7 @@ This method is effective only when called in
 ### removeResponseTrailer
 
 ``` {.sourceCode .cpp}
-void removeResponseTrailer(StringView key)
+void removeResponseTrailer(std::string_view key)
 ```
 
 Removes response trailer with the given key. No-op if the response
@@ -618,7 +618,7 @@ method is effective only when called in
 ### getResponseTrailer
 
 ``` {.sourceCode .cpp}
-WasmDataPtr getResponseTrailer(StringView key)
+WasmDataPtr getResponseTrailer(std::string_view key)
 ```
 
 Gets value of trailer with the given key. Returns empty string if
@@ -733,7 +733,7 @@ host stats sink.
 #### New
 
 ``` {.sourceCode .cpp}
-static Counter<Tags...>* New(StringView name, MetricTagDescriptor<Tags>... fieldnames)
+static Counter<Tags...>* New(std::string_view name, MetricTagDescriptor<Tags>... fieldnames)
 ```
 
 Create a new counter with the given metric name and tag names. Example
@@ -816,7 +816,7 @@ Returns current value of a counter.
 #### New
 
 ``` {.sourceCode .cpp}
-static Gauge<Tags...>* New(StringView name, MetricTagDescriptor<Tags>... fieldnames)
+static Gauge<Tags...>* New(std::string_view name, MetricTagDescriptor<Tags>... fieldnames)
 ```
 
 Create a new gauge with the given metric name and tag names. Example
@@ -900,7 +900,7 @@ Returns current value of a gauge.
 #### New
 
 ``` {.sourceCode .cpp}
-static Histogram<Tags...>* New(StringView name, MetricTagDescriptor<Tags>... fieldnames)
+static Histogram<Tags...>* New(std::string_view name, MetricTagDescriptor<Tags>... fieldnames)
 ```
 
 Create a new histogram object with the given metric name and tag names.
@@ -1138,7 +1138,7 @@ Returns the start pointer of the data.
 #### view
 
 ``` {.sourceCode .cpp}
-StringView view()
+std::string_view view()
 ```
 
 Returns data as a string view constructed with the start pointer and the
@@ -1155,7 +1155,7 @@ Returns data as a string by converting the string view to string.
 #### pairs
 
 ``` {.sourceCode .cpp}
-std::vector<std::pair<StringView, StringView>> pairs()
+std::vector<std::pair<std::string_view, StringView>> pairs()
 ```
 
 Returns a vector of string view pair parsed from the data.
diff --git a/proxy_wasm_api.h b/proxy_wasm_api.h
index 63cb94a..9790ad2 100644
--- a/proxy_wasm_api.h
+++ b/proxy_wasm_api.h
@@ -52,25 +52,25 @@ class ProxyException : std::runtime_error {
 };
 #endif
 
-inline WasmResult logTrace(StringView logMessage) {
+inline WasmResult logTrace(std::string_view logMessage) {
   return proxy_log(LogLevel::trace, logMessage.data(), logMessage.size());
 }
-inline WasmResult logDebug(StringView logMessage) {
+inline WasmResult logDebug(std::string_view logMessage) {
   return proxy_log(LogLevel::debug, logMessage.data(), logMessage.size());
 }
-inline WasmResult logInfo(StringView logMessage) {
+inline WasmResult logInfo(std::string_view logMessage) {
   return proxy_log(LogLevel::info, logMessage.data(), logMessage.size());
 }
-inline WasmResult logWarn(StringView logMessage) {
+inline WasmResult logWarn(std::string_view logMessage) {
   return proxy_log(LogLevel::warn, logMessage.data(), logMessage.size());
 }
-inline WasmResult logError(StringView logMessage) {
+inline WasmResult logError(std::string_view logMessage) {
   return proxy_log(LogLevel::error, logMessage.data(), logMessage.size());
 }
-inline WasmResult logCritical(StringView logMessage) {
+inline WasmResult logCritical(std::string_view logMessage) {
   return proxy_log(LogLevel::critical, logMessage.data(), logMessage.size());
 }
-inline void logAbort(StringView logMessag) {
+inline void logAbort(std::string_view logMessag) {
   logCritical(logMessag);
   abort();
 }
@@ -92,9 +92,9 @@ class WasmData {
   ~WasmData() { ::free(const_cast<char *>(data_)); }
   const char *data() { return data_; }
   size_t size() { return size_; }
-  StringView view() { return {data_, size_}; }
+  std::string_view view() { return {data_, size_}; }
   std::string toString() { return std::string(view()); }
-  std::vector<std::pair<StringView, StringView>> pairs();
+  std::vector<std::pair<std::string_view, std::string_view>> pairs();
   template <typename T> T proto() {
     T p;
     p.ParseFromArray(data_, size_);
@@ -110,8 +110,8 @@ class WasmData {
 };
 typedef std::unique_ptr<WasmData> WasmDataPtr;
 
-inline std::vector<std::pair<StringView, StringView>> WasmData::pairs() {
-  std::vector<std::pair<StringView, StringView>> result;
+inline std::vector<std::pair<std::string_view, std::string_view>> WasmData::pairs() {
+  std::vector<std::pair<std::string_view, std::string_view>> result;
   if (!data())
     return result;
   auto p = data();
@@ -122,11 +122,11 @@ inline std::vector<std::pair<StringView, StringView>> WasmData::pairs() {
   for (int i = 0; i < n; i++) {
     int size = *reinterpret_cast<const int *>(p);
     p += sizeof(int);
-    result[i].first = StringView(s, size);
+    result[i].first = std::string_view(s, size);
     s += size + 1;
     size = *reinterpret_cast<const int *>(p);
     p += sizeof(int);
-    result[i].second = StringView(s, size);
+    result[i].second = std::string_view(s, size);
     s += size + 1;
   }
   return result;
@@ -226,7 +226,7 @@ class GrpcStreamHandlerBase {
 
   // NB: with end_of_stream == true, callbacks can still occur: reset() to
   // prevent further callbacks.
-  WasmResult send(StringView message, bool end_of_stream);
+  WasmResult send(std::string_view message, bool end_of_stream);
   void close(); // NB: callbacks can still occur: reset() to prevent further
                 // callbacks.
   void reset();
@@ -300,10 +300,10 @@ class ContextBase {
 // module.
 class RootContext : public ContextBase {
 public:
-  RootContext(uint32_t id, StringView root_id) : ContextBase(id), root_id_(root_id) {}
+  RootContext(uint32_t id, std::string_view root_id) : ContextBase(id), root_id_(root_id) {}
   ~RootContext() {}
 
-  StringView root_id() { return root_id_; }
+  std::string_view root_id() { return root_id_; }
 
   RootContext *asRoot() override { return this; }
   Context *asContext() override { return nullptr; }
@@ -335,17 +335,18 @@ class RootContext : public ContextBase {
 
   // Default high level HTTP/gRPC interface. NB: overriding the low level
   // interface will disable this interface. Returns false on setup error.
-  WasmResult httpCall(StringView uri, const HeaderStringPairs &request_headers,
-                      StringView request_body, const HeaderStringPairs &request_trailers,
+  WasmResult httpCall(std::string_view uri, const HeaderStringPairs &request_headers,
+                      std::string_view request_body, const HeaderStringPairs &request_trailers,
                       uint32_t timeout_milliseconds, HttpCallCallback callback);
   // NB: the message is the response if status == OK and an error message
   // otherwise. Returns false on setup error.
-  WasmResult grpcSimpleCall(StringView service, StringView service_name, StringView method_name,
-                            const HeaderStringPairs &initial_metadata, StringView request,
-                            uint32_t timeout_milliseconds, GrpcSimpleCallCallback callback);
-  WasmResult grpcSimpleCall(StringView service, StringView service_name, StringView method_name,
-                            const HeaderStringPairs &initial_metadata, StringView request,
-                            uint32_t timeout_milliseconds,
+  WasmResult grpcSimpleCall(std::string_view service, std::string_view service_name,
+                            std::string_view method_name, const HeaderStringPairs &initial_metadata,
+                            std::string_view request, uint32_t timeout_milliseconds,
+                            GrpcSimpleCallCallback callback);
+  WasmResult grpcSimpleCall(std::string_view service, std::string_view service_name,
+                            std::string_view method_name, const HeaderStringPairs &initial_metadata,
+                            std::string_view request, uint32_t timeout_milliseconds,
                             std::function<void(size_t body_size)> success_callback,
                             std::function<void(GrpcStatus status)> failure_callback) {
     auto callback = [success_callback, failure_callback](GrpcStatus status, size_t body_size) {
@@ -358,13 +359,14 @@ class RootContext : public ContextBase {
     return grpcSimpleCall(service, service_name, method_name, initial_metadata, request,
                           timeout_milliseconds, callback);
   }
-  WasmResult grpcCallHandler(StringView service, StringView service_name, StringView method_name,
-                             const HeaderStringPairs &initial_metadata, StringView request,
+  WasmResult grpcCallHandler(std::string_view service, std::string_view service_name,
+                             std::string_view method_name,
+                             const HeaderStringPairs &initial_metadata, std::string_view request,
                              uint32_t timeout_milliseconds,
                              std::unique_ptr<GrpcCallHandlerBase> handler);
 #ifdef PROXY_WASM_PROTOBUF
-  WasmResult grpcSimpleCall(StringView service, StringView service_name, StringView method_name,
-                            const HeaderStringPairs &initial_metadata,
+  WasmResult grpcSimpleCall(std::string_view service, std::string_view service_name,
+                            std::string_view method_name, const HeaderStringPairs &initial_metadata,
                             const google::protobuf::MessageLite &request,
                             uint32_t timeout_milliseconds, GrpcSimpleCallCallback callback) {
     std::string serialized_request;
@@ -374,8 +376,8 @@ class RootContext : public ContextBase {
     return grpcSimpleCall(service, service_name, method_name, initial_metadata, serialized_request,
                           timeout_milliseconds, callback);
   }
-  WasmResult grpcSimpleCall(StringView service, StringView service_name, StringView method_name,
-                            const HeaderStringPairs &initial_metadata,
+  WasmResult grpcSimpleCall(std::string_view service, std::string_view service_name,
+                            std::string_view method_name, const HeaderStringPairs &initial_metadata,
                             const google::protobuf::MessageLite &request,
                             uint32_t timeout_milliseconds,
                             std::function<void(size_t body_size)> success_callback,
@@ -388,7 +390,8 @@ class RootContext : public ContextBase {
                           timeout_milliseconds, success_callback, failure_callback);
   }
   // Returns false on setup error.
-  WasmResult grpcCallHandler(StringView service, StringView service_name, StringView method_name,
+  WasmResult grpcCallHandler(std::string_view service, std::string_view service_name,
+                             std::string_view method_name,
                              const HeaderStringPairs &initial_metadata,
                              const google::protobuf::MessageLite &request,
                              uint32_t timeout_milliseconds,
@@ -402,7 +405,8 @@ class RootContext : public ContextBase {
   }
 #endif
   // Returns false on setup error.
-  WasmResult grpcStreamHandler(StringView service, StringView service_name, StringView method_name,
+  WasmResult grpcStreamHandler(std::string_view service, std::string_view service_name,
+                               std::string_view method_name,
                                const HeaderStringPairs &initial_metadata,
                                std::unique_ptr<GrpcStreamHandlerBase> handler);
 
@@ -419,7 +423,7 @@ class RootContext : public ContextBase {
   std::unordered_map<uint32_t, std::unique_ptr<GrpcStreamHandlerBase>> grpc_streams_;
 };
 
-RootContext *getRoot(StringView root_id);
+RootContext *getRoot(std::string_view root_id);
 
 // Context for a stream. The distinguished context id == 0 is used for
 // non-stream calls.
@@ -484,12 +488,13 @@ Context *getContext(uint32_t context_id);
 RootContext *getRootContext(uint32_t context_id);
 ContextBase *getContextBase(uint32_t context_id);
 
-using RootFactory = std::function<std::unique_ptr<RootContext>(uint32_t id, StringView root_id)>;
+using RootFactory =
+    std::function<std::unique_ptr<RootContext>(uint32_t id, std::string_view root_id)>;
 using ContextFactory = std::function<std::unique_ptr<Context>(uint32_t id, RootContext *root)>;
 
 // Create a factory from a class name.
 #define ROOT_FACTORY(_c)                                                                           \
-  [](uint32_t id, StringView root_id) -> std::unique_ptr<RootContext> {                            \
+  [](uint32_t id, std::string_view root_id) -> std::unique_ptr<RootContext> {                      \
     return std::make_unique<_c>(id, root_id);                                                      \
   }
 #define CONTEXT_FACTORY(_c)                                                                        \
@@ -502,10 +507,10 @@ using ContextFactory = std::function<std::unique_ptr<Context>(uint32_t id, RootC
 // register_MyContext(CONTEXT_FACTORY(MyContext));
 struct RegisterContextFactory {
   RegisterContextFactory(ContextFactory context_factory, RootFactory root_factory,
-                         StringView root_id = "");
-  explicit RegisterContextFactory(RootFactory root_factory, StringView root_id = "")
+                         std::string_view root_id = "");
+  explicit RegisterContextFactory(RootFactory root_factory, std::string_view root_id = "")
       : RegisterContextFactory(nullptr, root_factory, root_id) {}
-  explicit RegisterContextFactory(ContextFactory context_factory, StringView root_id = "")
+  explicit RegisterContextFactory(ContextFactory context_factory, std::string_view root_id = "")
       : RegisterContextFactory(context_factory, nullptr, root_id) {}
 };
 
@@ -518,7 +523,7 @@ inline std::pair<uint32_t, WasmDataPtr> getStatus() {
 }
 
 // Generic selector
-inline Optional<WasmDataPtr> getProperty(std::initializer_list<StringView> parts) {
+inline std::optional<WasmDataPtr> getProperty(std::initializer_list<std::string_view> parts) {
   size_t size = 0;
   for (auto part : parts) {
     size += part.size() + 1; // null terminated string value
@@ -547,7 +552,7 @@ inline Optional<WasmDataPtr> getProperty(std::initializer_list<StringView> parts
 // Durations are represented as int64 nanoseconds.
 // Timestamps are represented as int64 Unix nanoseconds.
 // Strings and bytes are represented as std::string.
-template <typename T> inline bool getValue(std::initializer_list<StringView> parts, T *out) {
+template <typename T> inline bool getValue(std::initializer_list<std::string_view> parts, T *out) {
   auto buf = getProperty(parts);
   if (!buf.has_value() || buf.value()->size() != sizeof(T)) {
     return false;
@@ -558,7 +563,7 @@ template <typename T> inline bool getValue(std::initializer_list<StringView> par
 
 // Specialization for bytes and string values
 template <>
-inline bool getValue<std::string>(std::initializer_list<StringView> parts, std::string *out) {
+inline bool getValue<std::string>(std::initializer_list<std::string_view> parts, std::string *out) {
   auto buf = getProperty(parts);
   if (!buf.has_value()) {
     return false;
@@ -569,7 +574,7 @@ inline bool getValue<std::string>(std::initializer_list<StringView> parts, std::
 
 // Specialization for message types (including struct value for lists and maps)
 template <typename T>
-inline bool getMessageValue(std::initializer_list<StringView> parts, T *value_ptr) {
+inline bool getMessageValue(std::initializer_list<std::string_view> parts, T *value_ptr) {
   auto buf = getProperty(parts);
   if (!buf.has_value()) {
     return false;
@@ -581,12 +586,12 @@ inline bool getMessageValue(std::initializer_list<StringView> parts, T *value_pt
   return value_ptr->ParseFromArray(buf.value()->data(), buf.value()->size());
 }
 
-inline WasmResult setFilterState(StringView key, StringView value) {
+inline WasmResult setFilterState(std::string_view key, std::string_view value) {
   return static_cast<WasmResult>(
       proxy_set_property(key.data(), key.size(), value.data(), value.size()));
 }
 
-inline WasmResult setFilterStateStringValue(StringView key, StringView s) {
+inline WasmResult setFilterStateStringValue(std::string_view key, std::string_view s) {
   return setFilterState(key, s);
 }
 
@@ -597,8 +602,8 @@ inline WasmResult continueResponse() { return proxy_continue_stream(WasmStreamTy
 inline WasmResult closeRequest() { return proxy_close_stream(WasmStreamType::Request); }
 inline WasmResult closeResponse() { return proxy_close_stream(WasmStreamType::Response); }
 
-inline WasmResult sendLocalResponse(uint32_t response_code, StringView response_code_details,
-                                    StringView body,
+inline WasmResult sendLocalResponse(uint32_t response_code, std::string_view response_code_details,
+                                    std::string_view body,
                                     const HeaderStringPairs &additional_response_headers,
                                     GrpcStatus grpc_status = GrpcStatus::InvalidCode) {
   const char *ptr = nullptr;
@@ -610,7 +615,7 @@ inline WasmResult sendLocalResponse(uint32_t response_code, StringView response_
 }
 
 // SharedData
-inline WasmResult getSharedData(StringView key, WasmDataPtr *value, uint32_t *cas = nullptr) {
+inline WasmResult getSharedData(std::string_view key, WasmDataPtr *value, uint32_t *cas = nullptr) {
   uint32_t dummy_cas;
   const char *value_ptr = nullptr;
   size_t value_size = 0;
@@ -624,11 +629,11 @@ inline WasmResult getSharedData(StringView key, WasmDataPtr *value, uint32_t *ca
   return WasmResult::Ok;
 }
 
-inline WasmResult setSharedData(StringView key, StringView value, uint32_t cas = 0) {
+inline WasmResult setSharedData(std::string_view key, std::string_view value, uint32_t cas = 0) {
   return proxy_set_shared_data(key.data(), key.size(), value.data(), value.size(), cas);
 }
 
-inline WasmDataPtr getSharedDataValue(StringView key, uint32_t *cas = nullptr) {
+inline WasmDataPtr getSharedDataValue(std::string_view key, uint32_t *cas = nullptr) {
   WasmDataPtr data;
   auto result = getSharedData(key, &data, cas);
   if (result != WasmResult::Ok) {
@@ -638,16 +643,17 @@ inline WasmDataPtr getSharedDataValue(StringView key, uint32_t *cas = nullptr) {
 }
 
 // SharedQueue
-inline WasmResult registerSharedQueue(StringView queue_name, uint32_t *token) {
+inline WasmResult registerSharedQueue(std::string_view queue_name, uint32_t *token) {
   return proxy_register_shared_queue(queue_name.data(), queue_name.size(), token);
 }
 
-inline WasmResult resolveSharedQueue(StringView vm_id, StringView queue_name, uint32_t *token) {
+inline WasmResult resolveSharedQueue(std::string_view vm_id, std::string_view queue_name,
+                                     uint32_t *token) {
   return proxy_resolve_shared_queue(vm_id.data(), vm_id.size(), queue_name.data(),
                                     queue_name.size(), token);
 }
 
-inline WasmResult enqueueSharedQueue(uint32_t token, StringView data) {
+inline WasmResult enqueueSharedQueue(uint32_t token, std::string_view data) {
   return proxy_enqueue_shared_queue(token, data.data(), data.size());
 }
 
@@ -660,22 +666,24 @@ inline WasmResult dequeueSharedQueue(uint32_t token, WasmDataPtr *data) {
 }
 
 // Headers/Trailers
-inline WasmResult addHeaderMapValue(WasmHeaderMapType type, StringView key, StringView value) {
+inline WasmResult addHeaderMapValue(WasmHeaderMapType type, std::string_view key,
+                                    std::string_view value) {
   return proxy_add_header_map_value(type, key.data(), key.size(), value.data(), value.size());
 }
 
-inline WasmDataPtr getHeaderMapValue(WasmHeaderMapType type, StringView key) {
+inline WasmDataPtr getHeaderMapValue(WasmHeaderMapType type, std::string_view key) {
   const char *value_ptr = nullptr;
   size_t value_size = 0;
   proxy_get_header_map_value(type, key.data(), key.size(), &value_ptr, &value_size);
   return std::make_unique<WasmData>(value_ptr, value_size);
 }
 
-inline WasmResult replaceHeaderMapValue(WasmHeaderMapType type, StringView key, StringView value) {
+inline WasmResult replaceHeaderMapValue(WasmHeaderMapType type, std::string_view key,
+                                        std::string_view value) {
   return proxy_replace_header_map_value(type, key.data(), key.size(), value.data(), value.size());
 }
 
-inline WasmResult removeHeaderMapValue(WasmHeaderMapType type, StringView key) {
+inline WasmResult removeHeaderMapValue(WasmHeaderMapType type, std::string_view key) {
   return proxy_remove_header_map_value(type, key.data(), key.size());
 }
 
@@ -697,16 +705,16 @@ inline WasmResult getHeaderMapSize(WasmHeaderMapType type, size_t *size) {
   return proxy_get_header_map_size(type, size);
 }
 
-inline WasmResult addRequestHeader(StringView key, StringView value) {
+inline WasmResult addRequestHeader(std::string_view key, std::string_view value) {
   return addHeaderMapValue(WasmHeaderMapType::RequestHeaders, key, value);
 }
-inline WasmDataPtr getRequestHeader(StringView key) {
+inline WasmDataPtr getRequestHeader(std::string_view key) {
   return getHeaderMapValue(WasmHeaderMapType::RequestHeaders, key);
 }
-inline WasmResult replaceRequestHeader(StringView key, StringView value) {
+inline WasmResult replaceRequestHeader(std::string_view key, std::string_view value) {
   return replaceHeaderMapValue(WasmHeaderMapType::RequestHeaders, key, value);
 }
-inline WasmResult removeRequestHeader(StringView key) {
+inline WasmResult removeRequestHeader(std::string_view key) {
   return removeHeaderMapValue(WasmHeaderMapType::RequestHeaders, key);
 }
 inline WasmDataPtr getRequestHeaderPairs() {
@@ -719,16 +727,16 @@ inline WasmResult getRequestHeaderSize(size_t *size) {
   return getHeaderMapSize(WasmHeaderMapType::RequestHeaders, size);
 }
 
-inline WasmResult addRequestTrailer(StringView key, StringView value) {
+inline WasmResult addRequestTrailer(std::string_view key, std::string_view value) {
   return addHeaderMapValue(WasmHeaderMapType::RequestTrailers, key, value);
 }
-inline WasmDataPtr getRequestTrailer(StringView key) {
+inline WasmDataPtr getRequestTrailer(std::string_view key) {
   return getHeaderMapValue(WasmHeaderMapType::RequestTrailers, key);
 }
-inline WasmResult replaceRequestTrailer(StringView key, StringView value) {
+inline WasmResult replaceRequestTrailer(std::string_view key, std::string_view value) {
   return replaceHeaderMapValue(WasmHeaderMapType::RequestTrailers, key, value);
 }
-inline WasmResult removeRequestTrailer(StringView key) {
+inline WasmResult removeRequestTrailer(std::string_view key) {
   return removeHeaderMapValue(WasmHeaderMapType::RequestTrailers, key);
 }
 inline WasmDataPtr getRequestTrailerPairs() {
@@ -741,16 +749,16 @@ inline WasmResult getRequestTrailerSize(size_t *size) {
   return getHeaderMapSize(WasmHeaderMapType::RequestTrailers, size);
 }
 
-inline WasmResult addResponseHeader(StringView key, StringView value) {
+inline WasmResult addResponseHeader(std::string_view key, std::string_view value) {
   return addHeaderMapValue(WasmHeaderMapType::ResponseHeaders, key, value);
 }
-inline WasmDataPtr getResponseHeader(StringView key) {
+inline WasmDataPtr getResponseHeader(std::string_view key) {
   return getHeaderMapValue(WasmHeaderMapType::ResponseHeaders, key);
 }
-inline WasmResult replaceResponseHeader(StringView key, StringView value) {
+inline WasmResult replaceResponseHeader(std::string_view key, std::string_view value) {
   return replaceHeaderMapValue(WasmHeaderMapType::ResponseHeaders, key, value);
 }
-inline WasmResult removeResponseHeader(StringView key) {
+inline WasmResult removeResponseHeader(std::string_view key) {
   return removeHeaderMapValue(WasmHeaderMapType::ResponseHeaders, key);
 }
 inline WasmDataPtr getResponseHeaderPairs() {
@@ -763,16 +771,16 @@ inline WasmResult getResponseHeaderSize(size_t *size) {
   return getHeaderMapSize(WasmHeaderMapType::ResponseHeaders, size);
 }
 
-inline WasmResult addResponseTrailer(StringView key, StringView value) {
+inline WasmResult addResponseTrailer(std::string_view key, std::string_view value) {
   return addHeaderMapValue(WasmHeaderMapType::ResponseTrailers, key, value);
 }
-inline WasmDataPtr getResponseTrailer(StringView key) {
+inline WasmDataPtr getResponseTrailer(std::string_view key) {
   return getHeaderMapValue(WasmHeaderMapType::ResponseTrailers, key);
 }
-inline WasmResult replaceResponseTrailer(StringView key, StringView value) {
+inline WasmResult replaceResponseTrailer(std::string_view key, std::string_view value) {
   return replaceHeaderMapValue(WasmHeaderMapType::ResponseTrailers, key, value);
 }
-inline WasmResult removeResponseTrailer(StringView key) {
+inline WasmResult removeResponseTrailer(std::string_view key) {
   return removeHeaderMapValue(WasmHeaderMapType::ResponseTrailers, key);
 }
 inline WasmDataPtr getResponseTrailerPairs() {
@@ -797,7 +805,7 @@ inline WasmResult getBufferStatus(WasmBufferType type, size_t *size, uint32_t *f
   return proxy_get_buffer_status(type, size, flags);
 }
 
-inline WasmResult setBuffer(WasmBufferType type, size_t start, size_t length, StringView data,
+inline WasmResult setBuffer(WasmBufferType type, size_t start, size_t length, std::string_view data,
                             size_t *new_size = nullptr) {
   auto result = proxy_set_buffer_bytes(type, start, length, data.data(), data.size());
   if (result == WasmResult::Ok && new_size)
@@ -842,8 +850,9 @@ inline void MakeHeaderStringPairsBuffer(const HeaderStringPairs &headers, void *
   *size_ptr = size;
 }
 
-inline WasmResult makeHttpCall(StringView uri, const HeaderStringPairs &request_headers,
-                               StringView request_body, const HeaderStringPairs &request_trailers,
+inline WasmResult makeHttpCall(std::string_view uri, const HeaderStringPairs &request_headers,
+                               std::string_view request_body,
+                               const HeaderStringPairs &request_trailers,
                                uint32_t timeout_milliseconds, uint32_t *token_ptr) {
   void *headers_ptr = nullptr, *trailers_ptr = nullptr;
   size_t headers_size = 0, trailers_size = 0;
@@ -859,7 +868,7 @@ inline WasmResult makeHttpCall(StringView uri, const HeaderStringPairs &request_
 
 // Low level metrics interface.
 
-inline WasmResult defineMetric(MetricType type, StringView name, uint32_t *metric_id) {
+inline WasmResult defineMetric(MetricType type, std::string_view name, uint32_t *metric_id) {
   return proxy_define_metric(type, name.data(), name.size(), metric_id);
 }
 
@@ -971,7 +980,7 @@ inline void MetricBase::partiallyResolveWithFields(const std::vector<std::string
 
 template <typename T> inline std::string toString(T t) { return std::to_string(t); }
 
-template <> inline std::string toString(StringView t) { return std::string(t); }
+template <> inline std::string toString(std::string_view t) { return std::string(t); }
 
 template <> inline std::string toString(const char *t) { return std::string(t); }
 
@@ -981,7 +990,7 @@ template <> inline std::string toString(bool t) { return t ? "true" : "false"; }
 
 template <typename T> struct StringToStringView { typedef T type; };
 
-template <> struct StringToStringView<std::string> { typedef StringView type; };
+template <> struct StringToStringView<std::string> { typedef std::string_view type; };
 
 inline uint32_t MetricBase::resolveFullName(const std::string &n) {
   auto it = metric_ids.find(n);
@@ -1034,10 +1043,10 @@ template <typename... Fields> inline uint64_t Metric::get(Fields... f) {
 }
 
 template <typename T> struct MetricTagDescriptor {
-  MetricTagDescriptor(StringView n) : name(n) {}
+  MetricTagDescriptor(std::string_view n) : name(n) {}
   MetricTagDescriptor(const char *n) : name(n) {}
   typedef T type;
-  StringView name;
+  std::string_view name;
 };
 
 template <typename T> inline MetricTag toMetricTag(const MetricTagDescriptor<T> &) { return {}; }
@@ -1050,7 +1059,7 @@ template <> inline MetricTag toMetricTag(const MetricTagDescriptor<std::string>
   return {std::string(d.name), MetricTag::TagType::String};
 }
 
-template <> inline MetricTag toMetricTag(const MetricTagDescriptor<StringView> &d) {
+template <> inline MetricTag toMetricTag(const MetricTagDescriptor<std::string_view> &d) {
   return {std::string(d.name), MetricTag::TagType::String};
 }
 
@@ -1100,9 +1109,9 @@ struct SimpleHistogram {
 };
 
 template <typename... Tags> struct Counter : public MetricBase {
-  static Counter<Tags...> *New(StringView name, MetricTagDescriptor<Tags>... fieldnames);
+  static Counter<Tags...> *New(std::string_view name, MetricTagDescriptor<Tags>... fieldnames);
 
-  Counter<Tags...>(StringView name, MetricTagDescriptor<Tags>... descriptors)
+  Counter<Tags...>(std::string_view name, MetricTagDescriptor<Tags>... descriptors)
       : Counter<Tags...>(std::string(name), std::vector<MetricTag>({toMetricTag(descriptors)...})) {
   }
 
@@ -1142,16 +1151,16 @@ template <typename... Tags> struct Counter : public MetricBase {
 };
 
 template <typename... Tags>
-inline Counter<Tags...> *Counter<Tags...>::New(StringView name,
+inline Counter<Tags...> *Counter<Tags...>::New(std::string_view name,
                                                MetricTagDescriptor<Tags>... descriptors) {
   return new Counter<Tags...>(std::string(name),
                               std::vector<MetricTag>({toMetricTag(descriptors)...}));
 }
 
 template <typename... Tags> struct Gauge : public MetricBase {
-  static Gauge<Tags...> *New(StringView name, MetricTagDescriptor<Tags>... fieldnames);
+  static Gauge<Tags...> *New(std::string_view name, MetricTagDescriptor<Tags>... fieldnames);
 
-  Gauge<Tags...>(StringView name, MetricTagDescriptor<Tags>... descriptors)
+  Gauge<Tags...>(std::string_view name, MetricTagDescriptor<Tags>... descriptors)
       : Gauge<Tags...>(std::string(name), std::vector<MetricTag>({toMetricTag(descriptors)...})) {}
 
   SimpleGauge resolve(Tags... f) {
@@ -1188,16 +1197,16 @@ template <typename... Tags> struct Gauge : public MetricBase {
 };
 
 template <typename... Tags>
-inline Gauge<Tags...> *Gauge<Tags...>::New(StringView name,
+inline Gauge<Tags...> *Gauge<Tags...>::New(std::string_view name,
                                            MetricTagDescriptor<Tags>... descriptors) {
   return new Gauge<Tags...>(std::string(name),
                             std::vector<MetricTag>({toMetricTag(descriptors)...}));
 }
 
 template <typename... Tags> struct Histogram : public MetricBase {
-  static Histogram<Tags...> *New(StringView name, MetricTagDescriptor<Tags>... fieldnames);
+  static Histogram<Tags...> *New(std::string_view name, MetricTagDescriptor<Tags>... fieldnames);
 
-  Histogram<Tags...>(StringView name, MetricTagDescriptor<Tags>... descriptors)
+  Histogram<Tags...>(std::string_view name, MetricTagDescriptor<Tags>... descriptors)
       : Histogram<Tags...>(std::string(name),
                            std::vector<MetricTag>({toMetricTag(descriptors)...})) {}
 
@@ -1227,15 +1236,16 @@ template <typename... Tags> struct Histogram : public MetricBase {
 };
 
 template <typename... Tags>
-inline Histogram<Tags...> *Histogram<Tags...>::New(StringView name,
+inline Histogram<Tags...> *Histogram<Tags...>::New(std::string_view name,
                                                    MetricTagDescriptor<Tags>... descriptors) {
   return new Histogram<Tags...>(std::string(name),
                                 std::vector<MetricTag>({toMetricTag(descriptors)...}));
 }
 
-inline WasmResult grpcCall(StringView service, StringView service_name, StringView method_name,
-                           const HeaderStringPairs &initial_metadata, StringView request,
-                           uint32_t timeout_milliseconds, uint32_t *token_ptr) {
+inline WasmResult grpcCall(std::string_view service, std::string_view service_name,
+                           std::string_view method_name, const HeaderStringPairs &initial_metadata,
+                           std::string_view request, uint32_t timeout_milliseconds,
+                           uint32_t *token_ptr) {
   void *metadata_ptr = nullptr;
   size_t metadata_size = 0;
   MakeHeaderStringPairsBuffer(initial_metadata, &metadata_ptr, &metadata_size);
@@ -1245,8 +1255,8 @@ inline WasmResult grpcCall(StringView service, StringView service_name, StringVi
 }
 
 #ifdef PROXY_WASM_PROTOBUF
-inline WasmResult grpcCall(StringView service, StringView service_name, StringView method_name,
-                           const HeaderStringPairs &initial_metadata,
+inline WasmResult grpcCall(std::string_view service, std::string_view service_name,
+                           std::string_view method_name, const HeaderStringPairs &initial_metadata,
                            const google::protobuf::MessageLite &request,
                            uint32_t timeout_milliseconds, uint32_t *token_ptr) {
   std::string serialized_request;
@@ -1258,7 +1268,8 @@ inline WasmResult grpcCall(StringView service, StringView service_name, StringVi
 }
 #endif
 
-inline WasmResult grpcStream(StringView service, StringView service_name, StringView method_name,
+inline WasmResult grpcStream(std::string_view service, std::string_view service_name,
+                             std::string_view method_name,
                              const HeaderStringPairs &initial_metadata, uint32_t *token_ptr) {
   void *metadata_ptr = nullptr;
   size_t metadata_size = 0;
@@ -1272,12 +1283,13 @@ inline WasmResult grpcCancel(uint32_t token) { return proxy_grpc_cancel(token);
 
 inline WasmResult grpcClose(uint32_t token) { return proxy_grpc_close(token); }
 
-inline WasmResult grpcSend(uint32_t token, StringView message, bool end_stream) {
+inline WasmResult grpcSend(uint32_t token, std::string_view message, bool end_stream) {
   return proxy_grpc_send(token, message.data(), message.size(), end_stream ? 1 : 0);
 }
 
-inline WasmResult RootContext::httpCall(StringView uri, const HeaderStringPairs &request_headers,
-                                        StringView request_body,
+inline WasmResult RootContext::httpCall(std::string_view uri,
+                                        const HeaderStringPairs &request_headers,
+                                        std::string_view request_body,
                                         const HeaderStringPairs &request_trailers,
                                         uint32_t timeout_milliseconds, HttpCallCallback callback) {
   uint32_t token = 0;
@@ -1298,11 +1310,11 @@ inline void RootContext::onHttpCallResponse(uint32_t token, uint32_t headers, si
   }
 }
 
-inline WasmResult RootContext::grpcSimpleCall(StringView service, StringView service_name,
-                                              StringView method_name,
-                                              const HeaderStringPairs &initial_metadata,
-                                              StringView request, uint32_t timeout_milliseconds,
-                                              Context::GrpcSimpleCallCallback callback) {
+inline WasmResult
+RootContext::grpcSimpleCall(std::string_view service, std::string_view service_name,
+                            std::string_view method_name, const HeaderStringPairs &initial_metadata,
+                            std::string_view request, uint32_t timeout_milliseconds,
+                            Context::GrpcSimpleCallCallback callback) {
   uint32_t token = 0;
   WasmResult result = grpcCall(service, service_name, method_name, initial_metadata, request,
                                timeout_milliseconds, &token);
@@ -1331,7 +1343,7 @@ inline void GrpcStreamHandlerBase::close() {
   // NB: else callbacks can still occur: reset() to prevent further callbacks.
 }
 
-inline WasmResult GrpcStreamHandlerBase::send(StringView message, bool end_of_stream) {
+inline WasmResult GrpcStreamHandlerBase::send(std::string_view message, bool end_of_stream) {
   WasmResult r = grpcSend(token_, message, end_of_stream);
   if (r != WasmResult::Ok) {
     return r;
@@ -1434,11 +1446,10 @@ inline void RootContext::onGrpcClose(uint32_t token, GrpcStatus status) {
   }
 }
 
-inline WasmResult RootContext::grpcCallHandler(StringView service, StringView service_name,
-                                               StringView method_name,
-                                               const HeaderStringPairs &initial_metadata,
-                                               StringView request, uint32_t timeout_milliseconds,
-                                               std::unique_ptr<GrpcCallHandlerBase> handler) {
+inline WasmResult RootContext::grpcCallHandler(
+    std::string_view service, std::string_view service_name, std::string_view method_name,
+    const HeaderStringPairs &initial_metadata, std::string_view request,
+    uint32_t timeout_milliseconds, std::unique_ptr<GrpcCallHandlerBase> handler) {
   uint32_t token = 0;
   auto result = grpcCall(service, service_name, method_name, initial_metadata, request,
                          timeout_milliseconds, &token);
@@ -1450,8 +1461,9 @@ inline WasmResult RootContext::grpcCallHandler(StringView service, StringView se
   return result;
 }
 
-inline WasmResult RootContext::grpcStreamHandler(StringView service, StringView service_name,
-                                                 StringView method_name,
+inline WasmResult RootContext::grpcStreamHandler(std::string_view service,
+                                                 std::string_view service_name,
+                                                 std::string_view method_name,
                                                  const HeaderStringPairs &initial_metadata,
                                                  std::unique_ptr<GrpcStreamHandlerBase> handler) {
   uint32_t token = 0;
diff --git a/proxy_wasm_intrinsics.cc b/proxy_wasm_intrinsics.cc
index 54d30f8..83d6c82 100644
--- a/proxy_wasm_intrinsics.cc
+++ b/proxy_wasm_intrinsics.cc
@@ -25,7 +25,7 @@ static std::unordered_map<int32_t, std::unique_ptr<ContextBase>> context_map;
 static std::unordered_map<std::string, RootContext *> root_context_map;
 
 RegisterContextFactory::RegisterContextFactory(ContextFactory context_factory,
-                                               RootFactory root_factory, StringView root_id) {
+                                               RootFactory root_factory, std::string_view root_id) {
   if (!root_factories) {
     root_factories = new std::unordered_map<std::string, RootFactory>;
     context_factories = new std::unordered_map<std::string, ContextFactory>;
@@ -114,7 +114,7 @@ RootContext *getRootContext(uint32_t context_id) {
   return it->second->asRoot();
 }
 
-RootContext *getRoot(StringView root_id) {
+RootContext *getRoot(std::string_view root_id) {
   auto it = root_context_map.find(std::string(root_id));
   if (it != root_context_map.end()) {
     return it->second;
diff --git a/proxy_wasm_intrinsics.h b/proxy_wasm_intrinsics.h
index f5d7457..3c8fbc1 100644
--- a/proxy_wasm_intrinsics.h
+++ b/proxy_wasm_intrinsics.h
@@ -31,9 +31,7 @@
 
 #include <cstdint>
 #include <string_view>
-using StringView = std::string_view;
 #include <optional>
-template <typename T> using Optional = std::optional<T>;
 
 #include "proxy_wasm_enums.h"
 #include "proxy_wasm_common.h"