TypeScript 配置

1
// MyRootType.ts
2
import * as MySdk from "...";
3
4
export interface MyRootType {
5
  foo: MySdk.MyRootTypeFoo;
6
}
7
8
// MyRootTypeFoo.ts
9
import * as MySdk from "...";
10
11
export interface MyRootTypeFoo {
12
  bar: MySdk.MyRootTypeFooBar;
13
}
14
15
// MyRootTypeFooBar.ts
16
import * as MySdk from "...";
17
18
export interface MyRootTypeFooBar {}

1
// MyRootType.ts
2
import * as MySdk from "...";
3
4
export interface MyRootType {
5
  foo: MyRootType.Foo;
6
}
7
8
export namespace MyRootType {
9
  export interface Foo {
10
    bar: Foo.Bar;
11
  }
12
13
  export namespace Foo {
14
    export interface Bar {}
15
  }
16
}

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

1
const response = await client.getFile(...);
2
const stream = response.stream();
3
// const arrayBuffer = await response.arrayBuffer();
4
// const blob = await response.blob();
5
// const bytes = await response.bytes();
6
const bodyUsed = response.bodyUsed;

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

1
{
2
    data: <BINARY_RESPONSE_TYPE>;
3
    contentLengthInBytes?: number;
4
    contentType?: string;
5
}

1
/**
2
  * @param {File | fs.ReadStream} file
3
  * @param {File[] | fs.ReadStream[]} fileList
4
  * @param {File | fs.ReadStream | undefined} maybeFile
5
  * @param {File[] | fs.ReadStream[] | undefined} maybeFileList
6
  * @param {Acme.MyRequest} request
7
  * @param {Service.RequestOptions} requestOptions - Request-specific configuration.
8
  *
9
  * @example
10
  *     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")], {})
11
  */
12
public async post(
13
    file: File | fs.ReadStream,
14
    fileList: File[] | fs.ReadStream[],
15
    maybeFile: File | fs.ReadStream | undefined,
16
    maybeFileList: File[] | fs.ReadStream[] | undefined,
17
    request: Acme.MyRequest,
18
    requestOptions?: Acme.RequestOptions
19
): Promise<void> {
20
  ...
21
}

1
/**
2
  * @param {Acme.MyRequest} request
3
  * @param {Service.RequestOptions} requestOptions - Request-specific configuration.
4
  *
5
  * @example
6
  *     await client.service.post({
7
  *        file: fs.createReadStream("/path/to/your/file"),
8
  *        fileList: [fs.createReadStream("/path/to/your/file")]
9
  *     })
10
  */
11
public async post(
12
    request: Acme.MyRequest,
13
    requestOptions?: Service.RequestOptions
14
): Promise<void> {
15
  ...
16
}

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

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

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

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

1
import { acme, AcmeClient } from "acme";

1
import { acme, AcmeSdkClient } from "acme";

1
const response = await client.callEndpoint(...);
2
if (response.ok) {
3
  console.log(response.body)
4
} else {
5
  console.error(respons.error)
6
}

1
interface Person {
2
  name: string;
3
  age?: number;
4
}

1
interface Person {
2
  name: string;
3
  age: number | undefined;
4
}

1
export interface User {
2
  user_id: string;
3
  display_name: string;
4
}

1
export interface User {
2
  userId: string;
3
  displayName: string;
4
}

1
// useBigInt: true
2
// noSerdeLayer: false
3
interface ObjectWithLongAndBigInt {
4
  longProp: bigint;
5
  bigIntProp: bigint;
6
}
7
8
// useBigInt: true
9
// noSerdeLayer: true
10
interface ObjectWithLongAndBigInt {
11
  longProp: bigint | number;
12
  bigIntProp: bigint | number;
13
}
14
15
// useBigInt: false
16
// noSerdeLayer: false
17
interface ObjectWithLongAndBigInt {
18
  longProp: number;
19
  bigIntProp: string;
20
}
21
22
// useBigInt: false
23
// noSerdeLayer: true
24
interface ObjectWithLongAndBigInt {
25
  longProp: number;
26
  bigIntProp: string;
27
}

1
// generated code
2
3
export type MyString = string;
4
5
export type OtherString = string;

1
// generated code
2
3
export type MyString = string & { __MyString: void };
4
export const MyString = (value: string): MyString => value as MyString;
5
6
export type OtherString = string & { __OtherString: void };
7
export const OtherString = (value: string): OtherString => value as OtherString;

1
// consuming the generated type
2
3
function printMyString(s: MyString): void {
4
  console.log("MyString: " + s);
5
}
6
7
// doesn't compile, "foo" is not assignable to MyString
8
printMyString("foo");
9
10
const otherString = OtherString("other-string");
11
// doesn't compile, otherString is not assignable to MyString
12
printMyString(otherString);
13
14
// compiles
15
const myString = MyString("my-string");
16
printMyString(myString);