Estoy creando un archivo de definición de TypeScript para una biblioteca js de terceros. Uno de los métodos de un objeto permite opciones, y una de las propiedades del objeto opciones acepta una cadena de la lista: "collapse", "expand", "end-expand", y "none".

Tengo una interfaz para el objeto de opciones:

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

¿Puede la interfaz aplicar esto, por lo que si incluye un IOptionsobjeto con la brace_stylepropiedad, solo permitirá una cadena que esté en la lista aceptable?

Esto fue lanzado en la versión 1.8 como "tipos literales de cadena"

Novedades de Typecript: tipos literales de cadena

Ejemplo de la página:

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

Prueba esto

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

export interface IReadings {
   param:ReadingTypes
}

Tal vez no sea exactamente lo que quería, pero Enumparece una solución perfecta para usted.

enum BraceStyle {Collapse, Expand, EndExpand, None}

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

Sin embargo, las enumeraciones están basadas en números. Significa que durante el tiempo de ejecución un valor real para, por ejemplo BraceStyle.Collapse, será 0 en este caso. Pero puede usarlos con otros scripts, incluso no mecanografiados, ya que se compilan en objetos. Así es como BraceStylese verá después de compilar y ejecutar:

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

Si desea cadenas en su lugar, puede usar una clase con miembros estáticos, como se describe aquí

TS ofrece una tipificación de valores de cadena específicos, que se denominan tipos literales de cadena .

Aquí hay un ejemplo de cómo usarlos:

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

En TypeScript 2.4 en adelante puede usar String Enums

Estoy a favor de este enfoque porque evita la necesidad de tener la misma cadena codificada en más de un lugar.

Es posible hacer una enumeración donde los valores son cadenas

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

Esta enumeración se puede usar como un tipo en una interfaz o clase

export interface UserOptions  {
  visibility:  VISIBILITY 
}