Genric trait implementation type hint issue in RUST Lang

generic_trait_type_hint.rs

trait Provide {
    fn credentials(&self) -> bool;
}

struct StaticProvider {
    foo: String
}
impl StaticProvider {
    pub fn new(value: String) -> StaticProvider {
        return StaticProvider {
            foo: value,
        }
    }
}
impl Provide for StaticProvider {
    fn credentials(&self) -> bool {
        return self.foo == "foo";
    }
}

struct BasicProvider {
    bar: String
}
impl BasicProvider {
    pub fn new(value: String) -> BasicProvider {
        return BasicProvider {
            bar: value,
        }
    }
}
impl Provide for BasicProvider {
    fn credentials(&self) -> bool {
        return self.bar == "bar";
    }
}

struct Client<P>
    where P: Provide
{
    provider: P
}

impl<P> Client<P>
    where P: Provide
{
    pub fn new(provider: P) -> Self {
        return Client {
            provider: provider,
        }
    }
}

pub fn main() {
    let dilema = "static";

    // How can I type hint this variable?
    // Considering that I do not have control on Client and Provider in real life
    // because it's generated code inside Rusto library (https://github.com/rusoto/rusoto)
    let client = if dilema == "static" {
        let provider = StaticProvider::new("foo".to_owned());
        Client::new(provider);
    } else {
        let provider = BasicProvider::new("bar".to_owned());
        Client::new(provider);
    };
    
    worker(client);

    /*if dilema == "static" {
        println!("foo: {}", client.provider.foo);
    } else {
        println!("bar: {}", client.provider.bar);
    }*/
}

// Here is my worker method that expect client to avoid evaluate dilema on all worker
pub fn worker(client: Client<???????>) {
}