use std::ops::Deref;

struct Client;

impl Client {
    fn new() -> Client {
        Client
    }
}

struct ConfiglessApi(Client);

impl ConfiglessApi {
    fn get_details(&self, config: usize) -> usize {
        1
    }

    fn get_something(&self) -> usize {
        1
    }
}

impl From<Client> for ConfiglessApi {
    fn from(a: Client) -> ConfiglessApi {
        ConfiglessApi(a)
    }
}

struct Api {
    inner: ConfiglessApi,
    config: usize,
}

impl Api {
    fn get_details(&self) -> usize {
        2
    }
}

impl Deref for Api {
    type Target = ConfiglessApi;

    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

fn main() {
    let client = Client::new();
    let configless_api = client.into();
    let api = Api {
        inner: configless_api,
        config: 0,
    };

    println!("{}", api.get_details()); // calls get_details for C
    println!("{}", api.deref().get_details(0)); // calls for get_details for B
    println!("{}", api.get_something()); // calls get_something for B because og dereferencing
    // println!("{}", api.get_details(0)); // does not work because of no dereferencing
}