TypeScript interface with XOR, {bar:string} xor {can:number}

typescript keyof
typescript infer
typescript mutually exclusive types
typescript constructorparameters
typescript xor operator
typescript unwrap promise type
typescript omit generic
typescript recursive partial

This question already has answers here:

As proposed in this issue, you can use conditional types (introduced in Typescript 2.8) to write a XOR type:

type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
type XOR<T, U> = (T | U) extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;

And you can use it like so:

type IFoo = XOR<{bar: string;}, {can: number}>;
let test: IFoo;
test = { bar: "test" } // OK
test = { can: 1 } // OK
test = { bar: "test",  can: 1 } // Error
test = {} // Error

TypeScript interface with XOR, {bar:string} xor {can:number}, How do I say that I want an interface to be one or the other, but not both or neither? interface IFoo { bar: string /*^XOR^*/ can: number; } Unambiguous Webpack config with Typescript. GitHub Gist: instantly share code, notes, and snippets.

You can use union types along with the never type to achieve this:

type IFoo = {
  bar: string; can?: never
} | {
    bar?: never; can: number
  };


let val0: IFoo = { bar: "hello" } // OK only bar
let val1: IFoo = { can: 22 } // OK only can
let val2: IFoo = { bar: "hello",  can: 22 } // Error foo and can
let val3: IFoo = {  } // Error neither foo or can

Issue #14094 · microsoft/TypeScript, Based on this comment TypeScript does not allow exclusive union types. What I'm suggesting is an exclusive or operator between two interfaces: Type Narrowing not being all it can be #17319 firstname: "Foo", lastname: "Bar" }; let stringOrNumber: XOR<string, number>; stringOrNumber = 14; All basic TypeScript types in one place 🤙. Contribute to krzkaczor/ts-essentials development by creating an account on GitHub.

You can get "one but not the other" with union and optional void type:

type IFoo = {bar: string; can?: void} | {bar?:void; can: number};

However, you have to use --strictNullChecks to prevent having neither.

XOR in union allows both · Issue #10575 · microsoft/TypeScript , TypeScript Version: 2.0.0 Code interface Project { projectId: string } findTask({ projectId: 'foo', organizationId: 'bar' }) should not work @RyanCavanaugh wrote a reply here which implies that or-unions work as XOR. that a type doesn't have a specific member, you can define that member as an optional The exact type of x and the return type will be inferred by Typescript once a function is actually passed. <T extends Partial<Parameters<F>[0]>>(a: T) => Once we pass our unary function we get a new function that takes a: T .

try this:

type Foo = {
    bar?: void;
    foo: string;
}

type Bar = {
    foo?: void;
    bar: number;
}

type FooBar = Foo | Bar;

// Error: Type 'string' is not assignable to type 'void'
let foobar: FooBar = {
    foo: "1",
    bar: 1
}

// no errors
let foo = {
    foo: "1"
}

XOR type, How do I say that I want an interface to be one or the other, but not both or neither? interface IFoo { bar: string /*^XOR^*/ can: number; }. Typescript interfaces do not guarantee that properties required by interfaces are gettable or settable #25650 Closed andy-ms mentioned this issue Jul 25, 2018

Package, Thus, we can compose our XOR s to allow for any number of interfaces to verify. Unfortunately, Typescript does not provide syntax for the composition of types, so Proposal A new invalid type that is not assignable to or from any other types. This includes not being assignable to or from any or never. It probably shouldn't even be assignable to invalid itself if that is possible, although I doubt t

Assignment operators, type ComplexObject = { simple: number; nested: { a: string; array: [{ bar: to StrictOmit in v3 , since the builtin Omit has become part of TypeScript 3.5 Following the code above, we can compare the behavior of Omit and StrictOmit . XOR. Gets the XOR (Exclusive-OR) type which could make 2 types exclude each other. This check is simplified for union types, just to say it has to be a "known" property on the union in general, not for this constituent. The main issue here is how unions are compared, when we are comparing constituent types, we do not know if we should check for "unknown" properties, because it might be one of the other types.

addition baz += false // 1 // Number + String -> concatenation bar += 'foo' Assuming the following variable // bar = 5 bar -= 2 // 3 bar -= 'foo' // NaN The left shift assignment operator moves the specified amount of bits to the left The bitwise XOR assignment operator uses the binary representation of not and or xor Booleans, low-precedence == != < > <= >= Numeric comparisons. eq ne lt gt le ge String comparisons, (Comma) List separator. Unchanged, but note that in order to flatten an array variable to a list (in order to append or prefix more items) one should use the | operator (see also Slip). For instance:

Comments

Fancy..................................
What about XOR<A | B | C | D> for more than two type?
Brilliant! I never realized never can be used to forbid a key from being present!
Great, that's what I was after. +1 & accepted