Gostaria de excluir uma única propriedade do tipo. Como eu posso fazer isso?

Por exemplo eu tenho

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

E eu quero excluir propriedades zpara obter

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

Para versões do TypeScript iguais ou superiores a 3,5

No TypeScript 3.5, o Omittipo foi adicionado à biblioteca padrão. Veja exemplos abaixo para saber como usá-lo.

Para versões do TypeScript abaixo de 3,5

No TypeScript 2.8, o Excludetipo foi adicionado à biblioteca padrão, o que permite que um tipo de omissão seja escrito simplesmente como:

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

Para versões do TypeScript abaixo de 2,8

Você não pode usar o Excludetipo nas versões abaixo de 2.8, mas pode criar um substituto para ele para usar o mesmo tipo de definição acima. No entanto, essa substituição funcionará apenas para tipos de string, portanto, não é tão poderosa quanto 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>>

E um exemplo desse tipo em 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}

Com o texto datilografado 2.8, você pode usar o novo Excludetipo interno. As notas de versão 2.8 mencionam isso na seção "Tipos condicionais predefinidos":

Nota: O tipo Excluir é uma implementação adequada do tipo Diff sugerido aqui. [...] não incluímos o tipo Omit, porque ele é escrito trivialmente como Pick<T, Exclude<keyof T, K>>.

Aplicando isso ao seu exemplo, o tipo XY pode ser definido como:

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

Eu encontrei uma solução ao declarar algumas variáveis ​​e usando o operador spread para inferir o tipo:

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

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

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

Funciona, mas ficaria feliz em ver uma solução melhor.

Se você preferir usar uma 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)

PS: Você encontrará muitas outras coisas úteis lá;)

Texto datilografado 3.5

A partir do TypeScript 3.5, o auxiliar Omit será incluído: TypeScript 3.5 RC - O tipo auxiliar Omit

Você pode usá-lo diretamente e deve remover sua própria definição do auxiliar Omit ao atualizar.

No texto datilografado 3.5+ :

interface TypographyProps {
    variant: string
    fontSize: number
}

type TypographyPropsMinusVariant = Omit<TypographyProps, "variant">

Eu faço assim:

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);