C# record auto castable to less specific, like in TypeScript

I am trying to achieve something which in TypeScript is so easy that I do not even think about it. I want something like Tuple, with namned typed properties, but I want it to be auto-compatible with less specific versions.

In Typescript:

{
   A: string,
   B: boolean
}

can be passed into function(x: {B: boolean}) or the function function(x: {A: string}) without any problems. How can this be done?

I have been thinking of Tuple, Record, Interfaces, Classes but nothing has really stuck.

Unfortunately, C# is strongly typed language, so it won't be that easy as in TypeScript. The thing you want try to achieve (which is OOP abstraction) is usually done with interfaces and base classes in C#.

For your example it could be following

public interface IInterfaceA 
{
    string A {get; set;}
}

public interface IInterfaceB 
{
    bool B {get; set;}
}

public class MyClass: IInterfaceA, IInterfaceB
{
   public string A {get; set;}
   public bool B {get; set;}
}

public class Program
{
	public static void Function1(IInterfaceA input) 
	{ 
		Console.WriteLine(input.A);
	}

    public static void Function2(IInterfaceB input) 
	{ 
		Console.WriteLine(input.B);
	}
	
	public static void Main()
	{
		var myClass = new MyClass() { A = "value", B = true };
        Function1(myClass);
        Function2(myClass);
	}
}