Estou criando um arquivo de definição TypeScript para uma biblioteca js de terceiros. Um dos métodos permite a um objeto opções, e uma das propriedades do objeto opções aceita uma string da lista: "collapse", "expand", "end-expand", e "none".

Eu tenho uma interface para o objeto de opções:

interface IOptions {
  indent_size?: number;
  indent_char?: string;
  brace_style?: // "collapse" | "expand" | "end-expand" | "none"
}

A interface pode impor isso; portanto, se você incluir um IOptionsobjeto na brace_stylepropriedade, ela permitirá apenas uma sequência que esteja na lista aceitável?

Isso foi lançado na versão 1.8 como "tipos literais de string"

O que há de novo no Typecript - Tipos literais de string

Exemplo da página:

interface AnimationOptions {
  deltaX: number;
  deltaY: number;
  easing: "ease-in" | "ease-out" | "ease-in-out";
}

Tente isto

export type ReadingTypes = 'some'|'variants'|'of'|'strings';

export interface IReadings {
   param:ReadingTypes
}

Talvez não seja exatamente o que você queria, mas Enumparece uma solução perfeita para você.

enum BraceStyle {Collapse, Expand, EndExpand, None}

interface IOptions {
  indent_size?: number;
  indent_char?: string;
  brace_style?: BraceStyle
}

As enums são, no entanto, baseadas em números. Isso significa que durante o tempo de execução, um valor real para, por exemplo BraceStyle.Collapse, será 0 neste caso. Mas você pode usá-los com outros scripts, mesmo não tipográficos, pois eles são compilados em objetos. É assim que BraceStylecuidará da compilação e execução:

{
    0: "Collapse",
    1: "Expand",
    2: "EndExpand",
    3: "None",
    Collapse: 0,
    Expand: 1,
    EndExpand: 2,
    None: 3
}

Se você desejar seqüências de caracteres, poderá usar uma classe com membros estáticos, conforme descrito aqui

O TS oferece uma digitação para valores de sequência específicos, chamados tipos literais de sequência .

Aqui está um exemplo de como usá-los:

type style =  "collapse" | "expand" | "end-expand" | "none";

interface IOptions {
  indent_size?: number;
  indent_char?: string;
  brace_style1?:  "collapse" | "expand" | "end-expand" | "none";
  brace_style2?:  style;
}

// Ok
let obj1: IOptions = {brace_style1: 'collapse'};

// Compile time error:
// Type '"collapsessss"' is not assignable to type '"collapse" | "expand" | "end-expand" | "none" | undefined'.
let obj2: IOptions = {brace_style1: 'collapsessss'};

function keysOf<T>(obj: T, key: keyof T) { return obj[key]; }
interface SomeInterface {
   a: string;
}
const instance: SomeInterface = { a: 'some value'};
let value = keysOf<SomeInterface>(instance, 'b'); // invalid
value =  keysOf<SomeInterface>(instance, 'a'); // valid

No TypeScript 2.4 em diante, você pode usar as String Enums

Eu sou a favor dessa abordagem porque evita a necessidade de ter a mesma string codificada em mais de um local.

É possível criar um enum onde os valores são cadeias

export enum VISIBILITY {
  PUBLISH = "publish",
  DRAFT = "draft"
}

Esse enum pode ser usado como um tipo em uma interface ou classe

export interface UserOptions  {
  visibility:  VISIBILITY 
}