TypeScript 配置

// MyRootType.ts
import * as MySdk from "...";
export interface MyRootType {
  foo: MySdk.MyRootTypeFoo;
}
// MyRootTypeFoo.ts
import * as MySdk from "...";
export interface MyRootTypeFoo {
  bar: MySdk.MyRootTypeFooBar;
}
// MyRootTypeFooBar.ts
import * as MySdk from "...";
export interface MyRootTypeFooBar {}

// MyRootType.ts
import * as MySdk from "...";
export interface MyRootType {
  foo: MyRootType.Foo;
}
export namespace MyRootType {
  export interface Foo {
    bar: Foo.Bar;
  }
  export namespace Foo {
    export interface Bar {}
  }
}

import { MyRootType } from MySdk;
const bar: MyRootType.Foo.Bar = {};

const response = await client.getFile(...);
const stream = response.stream();
// const arrayBuffer = await response.arrayBuffer();
// const blob = await response.blob();
// const bytes = await response.bytes();
const bodyUsed = response.bodyUsed;

import { BarClient } from '@acme/sdk/foo/bar';
// 仅导入 Bar 子包
const client = new BarClient({...});

{
    data: <BINARY_RESPONSE_TYPE>;
    contentLengthInBytes?: number;
    contentType?: string;
}

/**
  * @param {File | fs.ReadStream} file
  * @param {File[] | fs.ReadStream[]} fileList
  * @param {File | fs.ReadStream | undefined} maybeFile
  * @param {File[] | fs.ReadStream[] | undefined} maybeFileList
  * @param {Acme.MyRequest} request
  * @param {Service.RequestOptions} requestOptions - Request-specific configuration.
  *
  * @example
  *     await client.service.post(fs.createReadStream("/path/to/your/file"), [fs.createReadStream("/path/to/your/file")], fs.createReadStream("/path/to/your/file"), [fs.createReadStream("/path/to/your/file")], {})
  */
public async post(
    file: File | fs.ReadStream,
    fileList: File[] | fs.ReadStream[],
    maybeFile: File | fs.ReadStream | undefined,
    maybeFileList: File[] | fs.ReadStream[] | undefined,
    request: Acme.MyRequest,
    requestOptions?: Acme.RequestOptions
): Promise<void> {
  ...
}

/**
  * @param {Acme.MyRequest} request
  * @param {Service.RequestOptions} requestOptions - Request-specific configuration.
  *
  * @example
  *     await client.service.post({
  *        file: fs.createReadStream("/path/to/your/file"),
  *        fileList: [fs.createReadStream("/path/to/your/file")]
  *     })
  */
public async post(
    request: Acme.MyRequest,
    requestOptions?: Service.RequestOptions
): Promise<void> {
  ...
}

await service.getFoo("pathParamValue", { id: "SOME_ID" });

await service.getFoo({ pathParamName: "pathParamValue", id: "SOME_ID" });

import { AcmeApi, AcmeApiClient } from "@acme/node";

import { AcmePayments, AcmePaymentsClient } from "@acme/node";

import { acme, AcmeClient } from "acme";

import { acme, AcmeSdkClient } from "acme";

const response = await client.callEndpoint(...);
if (response.ok) {
  console.log(response.body)
} else {
  console.error(respons.error)
}

interface Person {
  name: string;
  age?: number;
}

interface Person {
  name: string;
  age: number | undefined;
}

export interface User {
  user_id: string;
  display_name: string;
}

export interface User {
  userId: string;
  displayName: string;
}

// useBigInt: true
// noSerdeLayer: false
interface ObjectWithLongAndBigInt {
  longProp: bigint;
  bigIntProp: bigint;
}
// useBigInt: true
// noSerdeLayer: true
interface ObjectWithLongAndBigInt {
  longProp: bigint | number;
  bigIntProp: bigint | number;
}
// useBigInt: false
// noSerdeLayer: false
interface ObjectWithLongAndBigInt {
  longProp: number;
  bigIntProp: string;
}
// useBigInt: false
// noSerdeLayer: true
interface ObjectWithLongAndBigInt {
  longProp: number;
  bigIntProp: string;
}

// 生成的代码
export type MyString = string;
export type OtherString = string;

// 生成的代码
export type MyString = string & { __MyString: void };
export const MyString = (value: string): MyString => value as MyString;
export type OtherString = string & { __OtherString: void };
export const OtherString = (value: string): OtherString => value as OtherString;

// 使用生成的类型
function printMyString(s: MyString): void {
  console.log("MyString: " + s);
}
// 不编译，"foo" 不能赋值给 MyString
printMyString("foo");
const otherString = OtherString("other-string");
// 不编译，otherString 不能赋值给 MyString
printMyString(otherString);
// 编译通过
const myString = MyString("my-string");
printMyString(myString);