So, before I figure out how tests are setup,
here's what it does:

#[derive(Debug, Deserialize, Serialize)]
#[typeshare]
pub struct Foo {
    pub value: String,
}

#[derive(Debug, Deserialize, Serialize)]
#[typeshare]
pub struct Bar {
    pub value: String,
}

#[derive(Debug, Deserialize, Serialize)]
#[typeshare]
pub struct Dummy {
    /// generates a normal nested definition
    pub foo: Foo,
    #[serde(flatten)]
    /// generates a flattened definition
    pub bar: Bar,
}

then

typeshare . --lang=typescript --output-file=definitions.ts`

becomes

export interface Foo {
	value: string;
}

export interface Bar {
	value: string;
}

export interface Dummy extends Bar {
	/** generates a normal nested definition */
	foo: Foo;
}

It also does not affect the other languages' implementations for Language,
but the presence of #[serde(flatten)] does produce an expected panic! on e.g.

typeshare . --lang=swift --output-file=definitions.swift

A workaround could be to allow the consumer to define a blank feature flag,
and maybe #[cfg_attr] can be parsed to allow basically to ignore it on languages which does not (yet or never) support it, e.g.:

#[derive(Debug, Deserialize, Serialize)]
#[typeshare]
pub struct Dummy {
    /// generates a normal nested definition
    pub foo: Foo,
    #[cfg_attr(feature = "typescript", serde(flatten)])] // <--- this line
    /// generates a flattened definition
    pub bar: Bar,
}

But yes ultimately it's not super ergonomic, so looking for your feedback :)

Thanks for the PR! I'll give it a review next week

cc @Lucretiel :)

Sorry for the delay, reviewing now. really like the idea of using inheritance to solve this, but I'm concerned that this solution won't have an equivalent in languages that don't have inheritance (like Go), or that do but for which it's an unusual pattern (like Swift). I'll give it a review as written but I'll also do some discussion with the typeshare team at our next team meeting.

Alright! I understand your concern, please keep me posted in case I miss the discussion ! 👌