How can this problem be solved so that this implementation can work in this code?

[AriBermeki]

 use tao::{
    event_loop::{EventLoop, EventLoopBuilder},
    window::{Window, WindowAttributes, WindowBuilder},
};
use wry::{WebView, WebViewAttributes, WebViewBuilder};




pub enum PyEventAPI {}





struct WindowFrame {
    win_attrs: WindowAttributes,
}


impl WindowFrame{

    pub fn new() -> WindowFrame {
        Self {
            win_attrs: Default::default(),
        }
    }
    pub fn with_title(&mut self, title:&str){
        self.win_attrs.title = title.into();
    }
}




pub struct WebViewFrame {
    pub webview_attrs: WebViewAttributes,
}

impl WebViewFrame {

    pub fn new() -> WebViewFrame {
        Self {
            webview_attrs: Default::default(),
        }
    }

    pub fn with_url(&mut self, url: &str) {
        self.webview_attrs.url = Some(url.into());
    }
}

 

 struct PyFrame {
     event_loop: EventLoop<PyEventAPI>,
     window: Window,
     webview: WebView,
 }
 

 impl PyFrame {

    pub fn new(
        window:&WindowFrame,
        webview:&WebViewFrame,
        _web_context: Option<bool>,
    ) -> PyFrame {
        
        let event_loop = EventLoopBuilder::<PyEventAPI>::with_user_event().build();
        let mut window_builder = WindowBuilder::new();

        // We need the Python class instance to set the WindowBuilder methods
      
        window_builder.window = window.win_attrs.clone();

        let main_window = window_builder.build(&event_loop).unwrap();

        #[cfg(any(
            target_os = "windows",
            target_os = "macos",
            target_os = "ios",
            target_os = "android"
        ))]
        let mut webview_builder = WebViewBuilder::new(&main_window);

        #[cfg(not(any(
            target_os = "windows",
            target_os = "macos",
            target_os = "ios",
            target_os = "android"
        )))]
        let mut webview_builder = {
            use tao::platform::unix::WindowExtUnix;
            use wry::WebViewBuilderExtUnix;
            let vbox = main_window.default_vbox().unwrap();
            WebViewBuilder::new_gtk(vbox)
        };
    // Set webview attributes
    let attributes = webview.clone();
    webview_builder.attrs = attributes;   //   <-------------------Error (mismatched types expected `WebViewAttributes`, 
                                            // found `&WebViewFrame`)

    let main_webview = webview_builder.build().unwrap();

        Self {
            event_loop: event_loop,
            window: main_window,
            webview: main_webview,
        }
    }
}

 
 // Implement `Send` for `WebViewFrame` if it is necessary and safe
 unsafe impl Send for WebViewFrame {}
 // Implement `Send` for `PyFrame` if it is necessary and safe
 unsafe impl Send for PyFrame {}
 



fn main() {
    // Initialize WindowFrame and WebViewFrame
    let window_frame = WindowFrame::new();
    let webview_frame = WebViewFrame::new();

    // Create PyFrame
    let py_frame = PyFrame::new(&window_frame, &webview_frame, None);

    // Run the event loop (if needed)
    py_frame.event_loop.run(|event, _, control_flow| {});
}