@lynx-js/lynx-library-headers 0.0.1-alpha.4 → 0.0.1

package/include/lynx/platform/embedder/public/lynx_group.h

@@ -1,70 +0,0 @@
-// Copyright 2025 The Lynx Authors. All rights reserved.
-// Licensed under the Apache License Version 2.0 that can be found in the
-// LICENSE file in the root directory of this source tree.
-#ifndef PLATFORM_EMBEDDER_PUBLIC_LYNX_GROUP_H_
-#define PLATFORM_EMBEDDER_PUBLIC_LYNX_GROUP_H_
-
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "capi/lynx_group_capi.h"
-
-namespace lynx {
-namespace pub {
-
-/**
- * @apidoc
- * @brief `LynxGroup` is a class that represents a group of Lynx views, allowing
- * developers to share JSContext between different Lynx views within the same
- * group.
- */
-class LynxGroup {
- public:
-  explicit LynxGroup(const std::string& name)
-      : group_(lynx_group_create(name.c_str())), name_(name) {}
-  LynxGroup(const std::string& name, const std::string& id)
-      : group_(lynx_group_create_with_id(name.c_str(), id.c_str())),
-        name_(name),
-        id_(id) {}
-
-  ~LynxGroup() { lynx_group_release(group_); }
-
-  std::string GetGroupName() const { return name_; }
-
-  std::string GetID() const { return id_; }
-
-  bool EnableJSGroupThread() const { return enable_js_group_thread_; }
-
-  void SetEnableJSGroupThread(bool enable) {
-    enable_js_group_thread_ = enable;
-    lynx_group_set_enable_js_group_thread(group_, enable);
-  }
-
-  void SetPreloadJSPaths(std::vector<std::string> paths) {
-    preload_js_paths_ = std::move(paths);
-    std::vector<const char*> c_paths(preload_js_paths_.size());
-    for (size_t i = 0; i < preload_js_paths_.size(); i++) {
-      c_paths[i] = preload_js_paths_[i].c_str();
-    }
-    lynx_group_set_preload_js_paths(group_, c_paths.data(),
-                                    preload_js_paths_.size());
-  }
-
-  lynx_group_t* Impl() { return group_; }
-
-  LynxGroup(const LynxGroup&) = delete;
-  LynxGroup& operator=(const LynxGroup&) = delete;
-
- private:
-  lynx_group_t* group_;
-  std::string name_;
-  std::string id_;
-  std::vector<std::string> preload_js_paths_;
-  bool enable_js_group_thread_ = false;
-};
-
-}  // namespace pub
-}  // namespace lynx
-
-#endif  // PLATFORM_EMBEDDER_PUBLIC_LYNX_GROUP_H_

package/include/lynx/platform/embedder/public/lynx_http_service.h

@@ -1,211 +0,0 @@
-// Copyright 2025 The Lynx Authors. All rights reserved.
-// Licensed under the Apache License Version 2.0 that can be found in the
-// LICENSE file in the root directory of this source tree.
-#ifndef PLATFORM_EMBEDDER_PUBLIC_LYNX_HTTP_SERVICE_H_
-#define PLATFORM_EMBEDDER_PUBLIC_LYNX_HTTP_SERVICE_H_
-
-#include <cstdint>
-#include <memory>
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-#include "capi/lynx_http_service_capi.h"
-#include "lynx_service_center.h"
-
-namespace lynx {
-namespace pub {
-
-/**
- * @apidoc
- * @brief `LynxHttpRequest` is a class that represents an HTTP request,
- * allowing developers to set request headers, request body, and other
- * request parameters.
- */
-class LynxHttpRequest {
- public:
-  explicit LynxHttpRequest(lynx_http_request_t* request) : request_(request) {
-    ExtractRequestInfo();
-  }
-  ~LynxHttpRequest() { lynx_http_request_release(request_); }
-
-  /**
-   * @apidoc
-   * @brief Get the URL of the HTTP request.
-   * @return The URL of the HTTP request.
-   */
-  const std::string& GetUrl() const { return url_; }
-
-  /**
-   * @apidoc
-   * @brief Get the method of the HTTP request.
-   * @return The method of the HTTP request.
-   */
-  const std::string& GetMethod() const { return method_; }
-
-  /**
-   * @apidoc
-   * @brief Get the headers of the HTTP request.
-   * @return The headers of the HTTP request.
-   */
-  const std::unordered_map<std::string, std::string>& GetHeaders() const {
-    return headers_;
-  }
-
-  /**
-   * @apidoc
-   * @brief Get the body of the HTTP request.
-   * @return The body of the HTTP request.
-   */
-  const std::vector<uint8_t>& GetBody() const { return body_; }
-
- private:
-  void ExtractRequestInfo() {
-    const char* url = lynx_http_request_get_url(request_);
-    url_ = url ? url : "";
-    const char* method = lynx_http_request_get_method(request_);
-    method_ = method ? method : "";
-    size_t header_count = lynx_http_request_get_header_count(request_);
-    for (unsigned i = 0; i < header_count; ++i) {
-      const char* key = nullptr;
-      const char* value = nullptr;
-      lynx_http_request_get_header(request_, i, &key, &value);
-      if (key && value) {
-        headers_[key] = value;
-      }
-    }
-    const uint8_t* body = nullptr;
-    size_t body_size = lynx_http_request_get_body(request_, &body);
-    if (body_size > 0 && body) {
-      body_.assign(body, body + body_size);
-    }
-  }
-
-  lynx_http_request_t* request_;
-  std::string url_;
-  std::string method_;
-  std::unordered_map<std::string, std::string> headers_;
-  std::vector<uint8_t> body_;
-};
-
-/**
- * @apidoc
- * @brief `LynxHttpResponse` is a class that represents an HTTP response,
- * allowing developers to set response status code, response status text,
- * response headers, and response body.
- */
-class LynxHttpResponse {
- public:
-  explicit LynxHttpResponse(lynx_http_response_t* response)
-      : response_(response) {}
-  ~LynxHttpResponse() { lynx_http_response_release(response_); }
-
-  /**
-   * @apidoc
-   * @brief Set the status code of the HTTP response.
-   * @param code The status code of the HTTP response.
-   */
-  void SetStatusCode(int code) {
-    lynx_http_response_set_status_code(response_, code);
-  }
-
-  /**
-   * @apidoc
-   * @brief Set the status text of the HTTP response.
-   * @param msg The status text of the HTTP response.
-   */
-  void SetStatusText(const char* msg) {
-    lynx_http_response_set_status_text(response_, msg);
-  }
-
-  /**
-   * @apidoc
-   * @brief Add a header to the HTTP response.
-   * @param key The key of the header.
-   * @param value The value of the header.
-   */
-  void AddHeader(const std::string& key, const std::string& value) {
-    lynx_http_response_add_header(response_, key.c_str(), value.c_str());
-  }
-
-  /**
-   * @apidoc
-   * @brief Set the body of the HTTP response.
-   * @param content The body content of the HTTP response.
-   * @param length The length of the body content.
-   * @param dtor The destructor of the body content.
-   * @param opaque The opaque data of the body content.
-   */
-  void SetBody(uint8_t* content, size_t length,
-               void (*dtor)(uint8_t*, size_t, void*) = nullptr,
-               void* opaque = nullptr) {
-    lynx_http_response_set_body(response_, content, length, dtor, opaque);
-  }
-
-  void Complete() { lynx_http_response_callback(response_); }
-
- private:
-  lynx_http_response_t* response_;
-};
-
-/**
- * @apidoc
- * @brief `LynxHttpService` is a class that represents a HTTP service, allowing
- * developers to send HTTP requests and receive HTTP responses.
- */
-class LynxHttpService : public LynxServiceBase,
-                        public std::enable_shared_from_this<LynxHttpService> {
- public:
-  LynxHttpService() = default;
-  ~LynxHttpService() = default;
-
-  void InitIfNeeded() override {
-    if (http_service_) {
-      return;
-    }
-    http_service_ = lynx_http_service_create_with_finalizer(
-        new std::weak_ptr<LynxHttpService>(weak_from_this()),
-        [](lynx_http_service_t* http_service, void* user_data) {
-          std::weak_ptr<LynxHttpService>* weak_ptr =
-              reinterpret_cast<std::weak_ptr<LynxHttpService>*>(user_data);
-          delete weak_ptr;
-        });
-    lynx_http_service_bind(http_service_, [](lynx_http_service_t* http_service,
-                                             lynx_http_request_t* request,
-                                             lynx_http_response_t* response) {
-      auto req = std::make_shared<LynxHttpRequest>(request);
-      auto resp = std::make_shared<LynxHttpResponse>(response);
-      std::weak_ptr<LynxHttpService>* weak_ptr =
-          reinterpret_cast<std::weak_ptr<LynxHttpService>*>(
-              lynx_http_service_get_user_data(http_service));
-      std::shared_ptr<LynxHttpService> shared_http_service =
-          weak_ptr ? weak_ptr->lock() : nullptr;
-      if (!shared_http_service) {
-        resp->SetStatusCode(-1);
-        resp->SetStatusText("http service is destroyed");
-      } else {
-        shared_http_service->Request(req, resp);
-      }
-    });
-  }
-
-  lynx_service_type_e GetServiceType() override { return kServiceTypeHttp; }
-
-  void* Impl() override { return http_service_; }
-
-  /**
-   * @apidoc
-   * @brief Send an HTTP request.
-   * @param request The HTTP request to be sent.
-   * @param response The HTTP response to receive the response.
-   */
-  virtual void Request(std::shared_ptr<LynxHttpRequest> request,
-                       std::shared_ptr<LynxHttpResponse> response) = 0;
-
- private:
-  lynx_http_service_t* http_service_ = nullptr;
-};
-}  // namespace pub
-}  // namespace lynx
-
-#endif  // PLATFORM_EMBEDDER_PUBLIC_LYNX_HTTP_SERVICE_H_

package/include/lynx/platform/embedder/public/lynx_load_meta.h

@@ -1,120 +0,0 @@
-// Copyright 2025 The Lynx Authors. All rights reserved.
-// Licensed under the Apache License Version 2.0 that can be found in the
-// LICENSE file in the root directory of this source tree.
-#ifndef PLATFORM_EMBEDDER_PUBLIC_LYNX_LOAD_META_H_
-#define PLATFORM_EMBEDDER_PUBLIC_LYNX_LOAD_META_H_
-
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#include "capi/lynx_load_meta_capi.h"
-#include "lynx_template_bundle.h"
-#include "lynx_template_data.h"
-
-namespace lynx {
-namespace pub {
-
-/**
- * @apidoc
- * @brief `LynxLoadMeta` is the metadata structure used by LynxView to load
- * templates. It will be used as the input parameter of loadTemplate. Users can
- * use `LynxLoadMeta` to specify many parameters of loading templates, such as
- * specifying template content, template initial data, and other additional
- * configuration information. url, binary_data, bundle are the required
- * parameters for template loading. You can pass only one or all of them. The
- * priority relationship is as follows: bundle > binary_data > url.
- */
-class LynxLoadMeta {
- public:
-  LynxLoadMeta() : load_meta_(lynx_load_meta_create()) {}
-  ~LynxLoadMeta() { lynx_load_meta_release(load_meta_); }
-
-  /**
-   * @apidoc
-   * @brief Set the url of the template to be loaded.
-   * @param url The url of the template to be loaded.
-   */
-  void SetUrl(const std::string& url) {
-    url_ = url;
-    lynx_load_meta_set_url(load_meta_, url_.c_str());
-  }
-
-  /**
-   * @apidoc
-   * @brief Set the binary data of the template to be loaded.
-   * @param content The binary data of the template to be loaded.
-   */
-  void SetBinaryData(std::vector<uint8_t> content) {
-    lynx_load_meta_set_binary_data(load_meta_, content.data(), content.size(),
-                                   nullptr, nullptr);
-  }
-
-  /**
-   * @apidoc
-   * @brief Set the binary data of the template to be loaded.
-   * @param content The binary data of the template to be loaded.
-   * @param length The length of the binary data.
-   * @param dtor The destructor of the binary data.
-   * @param opaque The opaque pointer of the binary data.
-   */
-  void SetBinaryData(uint8_t* content, size_t length,
-                     void (*dtor)(uint8_t*, size_t, void*) = nullptr,
-                     void* opaque = nullptr) {
-    lynx_load_meta_set_binary_data(load_meta_, content, length, dtor, opaque);
-  }
-
-  /**
-   * @apidoc
-   * @brief Set the template bundle of the template to be loaded.
-   * @param template_bundle The template bundle of the template to be loaded.
-   */
-  void SetTemplateBundle(std::shared_ptr<LynxTemplateBundle> template_bundle) {
-    template_bundle_ = std::move(template_bundle);
-    lynx_load_meta_set_template_bundle(load_meta_, template_bundle_->Impl());
-  }
-
-  /**
-   * @apidoc
-   * @brief Set the initial data of the template to be loaded.
-   * @param initial_data The initial data of the template to be loaded.
-   */
-  void SetInitialData(std::shared_ptr<LynxTemplateData> initial_data) {
-    initial_data_ = std::move(initial_data);
-    lynx_load_meta_set_initial_data(load_meta_, initial_data_->Impl());
-  }
-
-  /**
-   * @apidoc
-   * @brief Set the global props of the template to be loaded.
-   * @param global_props The global props of the template to be loaded.
-   */
-  void SetGlobalProps(std::shared_ptr<LynxTemplateData> global_props) {
-    global_props_ = std::move(global_props);
-    lynx_load_meta_set_global_props(load_meta_, global_props_->Impl());
-  }
-
-  std::string GetUrl() const { return url_; }
-
-  bool IsBundleValid() const {
-    return template_bundle_ != nullptr && template_bundle_->IsValid();
-  }
-
-  lynx_load_meta_t* Impl() { return load_meta_; }
-
-  LynxLoadMeta(const LynxLoadMeta&) = delete;
-  LynxLoadMeta& operator=(const LynxLoadMeta&) = delete;
-
- private:
-  lynx_load_meta_t* load_meta_;
-  std::string url_;
-  std::shared_ptr<LynxTemplateBundle> template_bundle_;
-  std::shared_ptr<LynxTemplateData> initial_data_;
-  std::shared_ptr<LynxTemplateData> global_props_;
-};
-
-}  // namespace pub
-}  // namespace lynx
-
-#endif  // PLATFORM_EMBEDDER_PUBLIC_LYNX_LOAD_META_H_

package/include/lynx/platform/embedder/public/lynx_native_module.h

@@ -1,9 +0,0 @@
-// Copyright 2025 The Lynx Authors. All rights reserved.
-// Licensed under the Apache License Version 2.0 that can be found in the
-// LICENSE file in the root directory of this source tree.
-#ifndef PLATFORM_EMBEDDER_PUBLIC_LYNX_NATIVE_MODULE_H_
-#define PLATFORM_EMBEDDER_PUBLIC_LYNX_NATIVE_MODULE_H_
-
-#include "capi/lynx_native_module_capi.h"
-
-#endif  // PLATFORM_EMBEDDER_PUBLIC_LYNX_NATIVE_MODULE_H_

package/include/lynx/platform/embedder/public/lynx_native_view.h

@@ -1,201 +0,0 @@
-// Copyright 2025 The Lynx Authors. All rights reserved.
-// Licensed under the Apache License Version 2.0 that can be found in the
-// LICENSE file in the root directory of this source tree.
-#ifndef PLATFORM_EMBEDDER_PUBLIC_LYNX_NATIVE_VIEW_H_
-#define PLATFORM_EMBEDDER_PUBLIC_LYNX_NATIVE_VIEW_H_
-
-#include <functional>
-
-#include "capi/lynx_native_view_capi.h"
-#include "lynx_value.h"
-#include "lynx_view.h"
-
-namespace lynx {
-namespace pub {
-
-/**
- * @apidoc
- * @brief LynxNativeView is the base class that to embed platform
- * view and external texture like Android TextureView, within Lynx view tree.
- */
-class LynxNativeView {
- public:
-  /**
-   * Method invocation results
-   */
-  static constexpr int kSuccess = 0;
-  static constexpr int kUnknown = 1;
-  static constexpr int kMethodNotFound = 3;
-  static constexpr int kInvalidParameter = 4;
-  static constexpr int kInvalidStateError = 7;
-
-  LynxNativeView() : native_view_(lynx_native_view_create(this)) {
-    lynx_native_view_bind_on_create(
-        native_view_, [](lynx_native_view_t* self, void* user_data) -> bool {
-          return static_cast<LynxNativeView*>(user_data)->OnCreate();
-        });
-    lynx_native_view_bind_on_attach(
-        native_view_, [](lynx_native_view_t* self, void* user_data) {
-          static_cast<LynxNativeView*>(user_data)->OnAttach();
-        });
-    lynx_native_view_bind_on_detach(
-        native_view_, [](lynx_native_view_t* self, void* user_data) {
-          static_cast<LynxNativeView*>(user_data)->OnDetach();
-        });
-    lynx_native_view_bind_on_destroy(
-        native_view_, [](lynx_native_view_t* self, void* user_data) {
-          static_cast<LynxNativeView*>(user_data)->OnDestroy();
-        });
-    lynx_native_view_bind_release(
-        native_view_, [](lynx_native_view_t* self, void* user_data) {
-          static_cast<LynxNativeView*>(user_data)->Release();
-        });
-    lynx_native_view_bind_on_layout_changed(
-        native_view_,
-        [](lynx_native_view_t* self, void* user_data, float left, float top,
-           float width, float height, float pixel_ratio) {
-          static_cast<LynxNativeView*>(user_data)->OnLayoutChanged(
-              left, top, width, height, pixel_ratio);
-        });
-    lynx_native_view_bind_on_properties_changed(
-        native_view_, [](lynx_native_view_t* self, void* user_data,
-                         lynx_value attrs, lynx_value events) {
-          static_cast<LynxNativeView*>(user_data)->OnPropertiesChanged(
-              LynxValue(attrs), LynxValue(events));
-        });
-    lynx_native_view_bind_on_motion_event(
-        native_view_, [](lynx_native_view_t* self, void* user_data,
-                         native_view_motion_event_t* event) {
-          static_cast<LynxNativeView*>(user_data)->OnMotionEvent(event);
-        });
-    lynx_native_view_bind_on_focus_changed(
-        native_view_, [](lynx_native_view_t* self, void* user_data,
-                         bool focused, bool is_leaf) {
-          static_cast<LynxNativeView*>(user_data)->OnFocusChanged(focused,
-                                                                  is_leaf);
-        });
-    lynx_native_view_bind_on_method_invoked(
-        native_view_,
-        [](lynx_native_view_t* self, void* user_data, const char* method,
-           lynx_value attrs, lynx_native_view_callback callback,
-           lynx_native_view_callback_info_t info) {
-          static_cast<LynxNativeView*>(user_data)->OnMethodInvoked(
-              method, LynxValue(attrs), [=](int code, LynxValue&& data) {
-                lynx_value_add_reference(nullptr, data.Value(), nullptr);
-                callback(info, code, data.Value());
-              });
-        });
-    lynx_native_view_bind_is_scroll_enabled(
-        native_view_, [](lynx_native_view_t* self, void* user_data) -> bool {
-          return static_cast<LynxNativeView*>(user_data)->IsScrollEnabled();
-          return false;
-        });
-    lynx_native_view_bind_is_surface_enabled(
-        native_view_, [](lynx_native_view_t* self, void* user_data) -> bool {
-          return static_cast<LynxNativeView*>(user_data)->IsSurfaceEnabled();
-          return false;
-        });
-    lynx_native_view_bind_surface_buffer_mode(
-        native_view_,
-        [](lynx_native_view_t* self,
-           void* user_data) -> lynx_surface_buffer_mode_t {
-          return static_cast<LynxNativeView*>(user_data)->SurfaceBufferMode();
-        });
-  }
-  virtual ~LynxNativeView() {}
-
-  /**
-   * @apidoc
-   * @brief LynxNativeView lifecycle and callbacks
-   */
-  virtual bool OnCreate() { return true; }
-  virtual void OnAttach() {}
-  virtual void OnDetach() {}
-  virtual void OnDestroy() {}
-  virtual void OnLayoutChanged(float left, float top, float width, float height,
-                               float pixel_ratio) {}
-  virtual void OnPropertiesChanged(const LynxValue& attrs,
-                                   const LynxValue& events) {}
-  virtual void OnMotionEvent(native_view_motion_event_t*) {}
-  virtual void OnFocusChanged(bool focused, bool is_leaf) {}
-  virtual void OnMethodInvoked(const char* method, const LynxValue& attrs,
-                               std::function<void(int, LynxValue&&)> callback) {
-    callback(kMethodNotFound, LynxValue(LynxValue::kCreateAsNullTag));
-  }
-  virtual bool IsScrollEnabled() { return false; }
-  virtual bool IsSurfaceEnabled() { return false; }
-  virtual lynx_surface_buffer_mode_t SurfaceBufferMode() {
-    return kDoubleBuffer;
-  }
-  virtual void Release() { delete this; }
-
-  /**
-   * @apidoc
-   * @brief Create and present surface with external graphics buffer
-   * @param width The width of surface
-   * @param height The height of surface
-   * @param transform The transformation matrix that will be applied on screen
-   * @param handle The resource handle of system graphics buffer
-   */
-  inline bool PresentSurface(int width, int height, const float* transform,
-                             lynx_surface_handle_t* handle) {
-    return lynx_native_view_present_surface(native_view_, width, height,
-                                            transform, handle);
-  }
-
-  /**
-   * @apidoc
-   * @brief Acquire the latest back buffer
-   * @param width The width of surface
-   * @param height The height of surface
-   * @return Platform native graphics handle. On Darwin this is IOSurfaceRef.
-   *         On Windows this is a D3D shared HANDLE for the back buffer,
-   *         not a texture/device pointer. Import it with the graphics
-   * API/device that matches the active Windows backend.
-   */
-  inline lynx_surface_handle_t* AcquireSurface(int width, int height) {
-    return lynx_native_view_acquire_surface(native_view_, width, height);
-  }
-
-  /**
-   * @apidoc
-   * @brief Swap the current back buffer to pending front
-   */
-  inline bool SwapBack() { return lynx_native_view_swap_back(native_view_); }
-
-  /**
-   * @apidoc
-   * @brief Trigger customized JS event to Lynx element
-   * @param name The name of event
-   * @param params The arguments be passed to JS handlers
-   */
-  inline void TriggerEvent(const char* name, LynxValue&& params) {
-    lynx_value_add_reference(nullptr, params.Value(), nullptr);
-    lynx_native_view_trigger_event(native_view_, name, params.Value());
-  }
-
-  /**
-   * @apidoc
-   * @brief Request focus if Lynx element need to capture input method
-   */
-  inline void RequestFocus() { lynx_native_view_request_focus(native_view_); }
-
-  /**
-   * @apidoc
-   * @brief Mark dirty to request redrawing
-   */
-  inline void MarkDirty() { lynx_native_view_mark_dirty(native_view_); }
-
-  inline lynx_native_view_t* native_view() { return native_view_; }
-
-  LynxNativeView(const LynxNativeView&) = delete;
-  LynxNativeView& operator=(const LynxNativeView&) = delete;
-
- private:
-  lynx_native_view_t* native_view_;
-};
-
-}  // namespace pub
-}  // namespace lynx
-
-#endif  // PLATFORM_EMBEDDER_PUBLIC_LYNX_NATIVE_VIEW_H_

package/include/lynx/platform/embedder/public/lynx_resource_request.h

@@ -1,56 +0,0 @@
-// Copyright 2025 The Lynx Authors. All rights reserved.
-// Licensed under the Apache License Version 2.0 that can be found in the
-// LICENSE file in the root directory of this source tree.
-#ifndef PLATFORM_EMBEDDER_PUBLIC_LYNX_RESOURCE_REQUEST_H_
-#define PLATFORM_EMBEDDER_PUBLIC_LYNX_RESOURCE_REQUEST_H_
-
-#include "capi/lynx_resource_request_capi.h"
-
-namespace lynx {
-namespace pub {
-namespace resource {
-/**
- * @apidoc
- * @brief `LynxResourceRequest` is a class that represents a resource request.
- */
-class LynxResourceRequest {
- public:
-  explicit LynxResourceRequest(lynx_resource_request_t* request)
-      : request_(request) {}
-
-  ~LynxResourceRequest() { lynx_resource_request_release(request_); }
-
-  /**
-   * @apidoc
-   * @brief Get the request id of the resource request.
-   * @return The request id of the resource request.
-   */
-  lynx_resource_request_id GetRequestId() {
-    return lynx_resource_request_get_id(request_);
-  }
-
-  /**
-   * @apidoc
-   * @brief Get the URL of the resource request.
-   * @return The URL of the resource request.
-   */
-  const char* GetUrl() { return lynx_resource_request_get_url(request_); }
-
-  /**
-   * @apidoc
-   * @brief Get the type of the resource request.
-   * @return The type of the resource request.
-   */
-  lynx_resource_type_e GetType() {
-    return lynx_resource_request_get_type(request_);
-  }
-
- private:
-  lynx_resource_request_t* request_;
-};
-
-}  // namespace resource
-}  // namespace pub
-}  // namespace lynx
-
-#endif  // PLATFORM_EMBEDDER_PUBLIC_LYNX_RESOURCE_REQUEST_H_