Me gustaría excluir una sola propiedad del tipo. ¿Cómo puedo hacer eso?

Por ejemplo tengo

interface XYZ {
  x: number;
  y: number;
  z: number;
}

Y quiero excluir la propiedad zpara obtener

type XY = { x: number, y: number };

Para versiones de TypeScript de 3.5 o superior

En TypeScript 3.5, el Omittipo se agregó a la biblioteca estándar. Vea los ejemplos a continuación para saber cómo usarlo.

Para versiones de TypeScript inferiores a 3.5

En TypeScript 2.8, el Excludetipo se agregó a la biblioteca estándar, lo que permite escribir un tipo de omisión simplemente como:

type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>

Para versiones de TypeScript inferiores a 2.8

No puede usar el Excludetipo en las versiones inferiores a 2.8, pero puede crear un reemplazo para usar el mismo tipo de definición que el anterior. Sin embargo, este reemplazo solo funcionará para los tipos de cadena, por lo que no es tan poderoso como Exclude.

// Functionally the same as Exclude, but for strings only.
type Diff<T extends string, U extends string> = ({[P in T]: P } & {[P in U]: never } & { [x: string]: never })[T]
type Omit<T, K extends keyof T> = Pick<T, Diff<keyof T, K>>

Y un ejemplo de ese tipo en uso:

interface Test {
    a: string;
    b: number;
    c: boolean;
}

// Omit a single property:
type OmitA = Omit<Test, "a">; // Equivalent to: {b: number, c: boolean}

// Or, to omit multiple properties:
type OmitAB = Omit<Test, "a"|"b">; // Equivalent to: {c: boolean}

Con el mecanografiado 2.8, puede usar el nuevo tipo incorporado Exclude. Las notas de la versión 2.8 en realidad mencionan esto en la sección "Tipos condicionales predefinidos":

Nota: El tipo Excluir es una implementación adecuada del tipo Diff sugerido aquí. [...] No incluimos el tipo Omitir porque está escrito trivialmente como Pick<T, Exclude<keyof T, K>>.

Aplicando esto a su ejemplo, el tipo XY podría definirse como:

type XY = Pick<XYZ, Exclude<keyof XYZ, "z">>

He encontrado solución declarando algunas variables y usando el operador de propagación para inferir el tipo:

interface XYZ {
  x: number;
  y: number;
  z: number;
}

declare var { z, ...xy }: XYZ;

type XY = typeof xy; // { x: number; y: number; }

Funciona, pero me alegraría ver una solución mejor.

Si prefiere usar una biblioteca, use ts-essentials .

import { Omit } from "ts-essentials";

type ComplexObject = {
  simple: number;
  nested: {
    a: string;
    array: [{ bar: number }];
  };
};

type SimplifiedComplexObject = Omit<ComplexObject, "nested">;

// Result:
// {
//  simple: number
// }

// if you want to Omit multiple properties just use union type:
type SimplifiedComplexObject = Omit<ComplexObject, "nested" | "simple">;

// Result:
// { } (empty type)

PD: Encontrarás muchas otras cosas útiles allí;)

Mecanografiado 3.5

A partir de Typescript 3.5, se incluirá el asistente de omisión : TypeScript 3.5 RC - El tipo de ayuda de omisión

Puede usarlo directamente, y debe eliminar su propia definición del ayudante de omisión al actualizar.

En Typecript 3.5+ :

interface TypographyProps {
    variant: string
    fontSize: number
}

type TypographyPropsMinusVariant = Omit<TypographyProps, "variant">

Me gusta eso:

interface XYZ {
  x: number;
  y: number;
  z: number;
}
const a:XYZ = {x:1, y:2, z:3};
const { x, y, ...last } = a;
const { z, ...firstTwo} = a;
console.log(firstTwo, last);