如何封装TypeScript中间类型，仅对外暴露FinalType？

我希望定义一个复杂的TypeScript类型FinalType，但由于其复杂度，需要声明IntermediaryType、IntermediaryType2这两个中间类型，而它们会污染当前作用域。相关代码如下：

type IntermediaryType = { decisiveKey: true, mutatedKey: (params: any) => void, } | { decisiveKey: false, mutatedKey?: false, }
interface IntermediaryType2 { foo?: string, bar?: boolean, }
type FinalType = IntermediaryType & IntermediaryType2;
const Foo = (param: FinalType) => {}
Foo({ decisiveKey: true, mutatedKey: () => {}, });

我想让这些中间类型不可被外部访问，仅允许使用FinalType。我尝试过用代码块包裹中间类型和FinalType，但这样无法访问FinalType；尝试使用return或export也无效。我理想的写法类似：

type FinalType = {
  type IntermediaryType = { decisiveKey: true, mutatedKey: (params: any) => void, } | { decisiveKey: false, mutatedKey?: false, }
  interface IntermediaryType2 { foo?: string, bar?: boolean, }
  return IntermediaryType & IntermediaryType2;
}
const Foo = (param: FinalType) => {}
Foo({ decisiveKey: true, mutatedKey: () => {}, });

目前我借助@Aluan Haddad的方案，用命名空间实现了需求，但希望能有更简洁的语法糖：

namespace _ {
  type IntermediaryType = { decisiveKey: true, mutatedKey: (params: any) => void, } | { decisiveKey: false, mutatedKey?: false, }
  interface IntermediaryType2 { foo?: string, bar?: boolean, }
  export type FinalType = IntermediaryType & IntermediaryType2;
};
type FinalType = _.FinalType;
const Foo = (param: FinalType) => {}
Foo({ decisiveKey: true, mutatedKey: () => {}, });

请问有没有更简洁的实现方式？

好问题！在TypeScript中隔离中间类型确实是个常见需求，尤其是构建复杂类型时不想污染当前作用域。这里有几种比命名空间更简洁的实现方式：

1. 箭头函数风格的立即执行类型（最接近你的理想写法） #

利用TypeScript对箭头函数返回值的类型推断能力，我们可以把中间类型嵌套在一个匿名箭头函数类型里，只返回最终的FinalType。中间类型会被限制在这个箭头函数的局部类型作用域中，外部完全无法访问：

type FinalType = (() => {
  type IntermediaryType = { decisiveKey: true, mutatedKey: (params: any) => void } | { decisiveKey: false, mutatedKey?: false };
  interface IntermediaryType2 { foo?: string, bar?: boolean };
  return IntermediaryType & IntermediaryType2;
})();

// 正常使用FinalType
const Foo = (param: FinalType) => {};
Foo({ decisiveKey: true, mutatedKey: () => {} });

// 尝试访问中间类型会直接报错：找不到名称“IntermediaryType”
// console.log(IntermediaryType); // Error: Cannot find name 'IntermediaryType'

这个写法几乎和你设想的“理想写法”一致，不需要额外的命名空间或模块，代码紧凑且直观。

2. 模块隔离（推荐用于大型项目） #

如果你的代码是在ES模块环境中（存在import/export语句），最干净的方式是把中间类型放在单独的模块文件里，只导出FinalType：

创建一个types.ts文件：

// types.ts
// 中间类型仅在当前模块可见
type IntermediaryType = { decisiveKey: true, mutatedKey: (params: any) => void } | { decisiveKey: false, mutatedKey?: false };
interface IntermediaryType2 { foo?: string, bar?: boolean };

// 只导出最终类型
export type FinalType = IntermediaryType & IntermediaryType2;

然后在主文件中导入使用：

import type { FinalType } from './types';

const Foo = (param: FinalType) => {};
Foo({ decisiveKey: true, mutatedKey: () => {} });

这种方式完全隔离了中间类型，符合TypeScript的模块化最佳实践，尤其适合多人协作或大型项目。

3. 匿名模块声明（非模块环境） #

如果你的代码不在模块环境中（没有import/export），可以用匿名declare module块来包裹中间类型，模拟模块隔离效果：

declare module 'hidden-types' {
  type IntermediaryType = { decisiveKey: true, mutatedKey: (params: any) => void } | { decisiveKey: false, mutatedKey?: false };
  interface IntermediaryType2 { foo?: string, bar?: boolean };
  export type FinalType = IntermediaryType & IntermediaryType2;
}

// 导入FinalType
import type { FinalType } from 'hidden-types';

const Foo = (param: FinalType) => {};
Foo({ decisiveKey: true, mutatedKey: () => {} });

这里的模块名hidden-types可以是任意字符串，只要不与真实存在的模块冲突即可，中间类型会被严格限制在这个声明块内部。

内容的提问来源于stack exchange，提问作者Orelsanpls