@databricks/sdk-tokenmanagement 0.0.0-dev → 0.1.0-dev.1

package/src/v1/client.ts

@@ -0,0 +1,232 @@
+// Code generated from API definition by Databricks SDK Generator. DO NOT EDIT.
+
+import {VERSION as AUTH_VERSION} from '@databricks/sdk-auth';
+import type {Call} from '@databricks/sdk-core/api';
+import {createDefault} from '@databricks/sdk-core/clientinfo';
+import type {Logger} from '@databricks/sdk-core/logger';
+import {NoOpLogger} from '@databricks/sdk-core/logger';
+import type {CallOptions} from '@databricks/sdk-options/call';
+import type {ClientOptions} from '@databricks/sdk-options/client';
+import type {HttpClient} from '@databricks/sdk-core/http';
+import {newHttpClient} from './transport';
+import {
+  buildHttpRequest,
+  executeCall,
+  executeHttpCall,
+  marshalRequest,
+  parseResponse,
+} from './utils';
+import pkgJson from '../../package.json' with {type: 'json'};
+import type {
+  AdminTokenInfo,
+  CreateOnBehalfOfTokenRequest,
+  CreateOnBehalfOfTokenRequest_Response,
+  GetTokenRequest,
+  GetTokenRequest_Response,
+  ListTokensRequest,
+  ListTokensRequest_Response,
+  RevokeTokenRequest,
+  RevokeTokenRequest_Response,
+  UpdateToken,
+} from './model';
+import {
+  marshalCreateOnBehalfOfTokenRequestSchema,
+  marshalUpdateTokenSchema,
+  unmarshalAdminTokenInfoSchema,
+  unmarshalCreateOnBehalfOfTokenRequest_ResponseSchema,
+  unmarshalGetTokenRequest_ResponseSchema,
+  unmarshalListTokensRequest_ResponseSchema,
+  unmarshalRevokeTokenRequest_ResponseSchema,
+} from './model';
+
+// Package identity segment for this client to be used in the User-Agent header.
+const PACKAGE_SEGMENT = {
+  key: 'sdk-js-' + pkgJson.name.replace(/^@[^/]+\/sdk-/, ''),
+  value: pkgJson.version,
+};
+
+export class TokenmanagementClient {
+  private readonly host: string;
+  // Workspace ID used to route workspace-level calls on unified hosts (SPOG).
+  // When set, workspace-level methods send X-Databricks-Org-Id on every
+  // request.
+  private readonly workspaceId: string | undefined;
+  private readonly httpClient: HttpClient;
+  private readonly logger: Logger;
+  // User-Agent header value. Composed once at construction from
+  // createDefault() merged with this package's identity and the active
+  // credential's name.
+  private readonly userAgent: string;
+
+  constructor(options: ClientOptions) {
+    if (options.host === undefined) {
+      throw new Error('Host is required.');
+    }
+    this.host = options.host.replace(/\/$/, '');
+    this.workspaceId = options.workspaceId;
+    this.logger = options.logger ?? new NoOpLogger();
+    const info = createDefault()
+      .with(PACKAGE_SEGMENT)
+      .with({key: 'sdk-js-auth', value: AUTH_VERSION})
+      .with({key: 'auth', value: options.credentials?.name() ?? 'default'});
+    this.userAgent = info.toString();
+    this.httpClient = newHttpClient(options);
+  }
+
+  /** Creates a token on behalf of a service principal. */
+  async createOnBehalfOfToken(
+    req: CreateOnBehalfOfTokenRequest,
+    options?: CallOptions
+  ): Promise<CreateOnBehalfOfTokenRequest_Response> {
+    const url = `${this.host}/api/2.0/token-management/on-behalf-of/tokens`;
+    const body = marshalRequest(req, marshalCreateOnBehalfOfTokenRequestSchema);
+    let resp: CreateOnBehalfOfTokenRequest_Response | undefined;
+    const call: Call = async (callSignal?: AbortSignal): Promise<void> => {
+      const headers = new Headers({'Content-Type': 'application/json'});
+      if (this.workspaceId !== undefined) {
+        headers.set('X-Databricks-Org-Id', this.workspaceId);
+      }
+      headers.set('User-Agent', this.userAgent);
+      const httpReq = buildHttpRequest('POST', url, headers, callSignal, body);
+      const respBody = await executeHttpCall({
+        request: httpReq,
+        httpClient: this.httpClient,
+        logger: this.logger,
+      });
+      resp = parseResponse(
+        respBody,
+        unmarshalCreateOnBehalfOfTokenRequest_ResponseSchema
+      );
+    };
+    await executeCall(call, options);
+    if (resp === undefined) {
+      throw new Error('API call completed without a result.');
+    }
+    return resp;
+  }
+
+  /** Deletes a token, specified by its ID. */
+  async deleteToken(
+    req: RevokeTokenRequest,
+    options?: CallOptions
+  ): Promise<RevokeTokenRequest_Response> {
+    const url = `${this.host}/api/2.0/token-management/tokens/${req.tokenId ?? ''}`;
+    let resp: RevokeTokenRequest_Response | undefined;
+    const call: Call = async (callSignal?: AbortSignal): Promise<void> => {
+      const headers = new Headers();
+      if (this.workspaceId !== undefined) {
+        headers.set('X-Databricks-Org-Id', this.workspaceId);
+      }
+      headers.set('User-Agent', this.userAgent);
+      const httpReq = buildHttpRequest('DELETE', url, headers, callSignal);
+      const respBody = await executeHttpCall({
+        request: httpReq,
+        httpClient: this.httpClient,
+        logger: this.logger,
+      });
+      resp = parseResponse(
+        respBody,
+        unmarshalRevokeTokenRequest_ResponseSchema
+      );
+    };
+    await executeCall(call, options);
+    if (resp === undefined) {
+      throw new Error('API call completed without a result.');
+    }
+    return resp;
+  }
+
+  /** Gets information about a token, specified by its ID. */
+  async getToken(
+    req: GetTokenRequest,
+    options?: CallOptions
+  ): Promise<GetTokenRequest_Response> {
+    const url = `${this.host}/api/2.0/token-management/tokens/${req.tokenId ?? ''}`;
+    let resp: GetTokenRequest_Response | undefined;
+    const call: Call = async (callSignal?: AbortSignal): Promise<void> => {
+      const headers = new Headers();
+      if (this.workspaceId !== undefined) {
+        headers.set('X-Databricks-Org-Id', this.workspaceId);
+      }
+      headers.set('User-Agent', this.userAgent);
+      const httpReq = buildHttpRequest('GET', url, headers, callSignal);
+      const respBody = await executeHttpCall({
+        request: httpReq,
+        httpClient: this.httpClient,
+        logger: this.logger,
+      });
+      resp = parseResponse(respBody, unmarshalGetTokenRequest_ResponseSchema);
+    };
+    await executeCall(call, options);
+    if (resp === undefined) {
+      throw new Error('API call completed without a result.');
+    }
+    return resp;
+  }
+
+  /** Lists all tokens associated with the specified workspace or user. */
+  async listTokens(
+    req: ListTokensRequest,
+    options?: CallOptions
+  ): Promise<ListTokensRequest_Response> {
+    const url = `${this.host}/api/2.0/token-management/tokens`;
+    const params = new URLSearchParams();
+    if (req.createdById !== undefined) {
+      params.append('created_by_id', String(req.createdById));
+    }
+    if (req.createdByUsername !== undefined) {
+      params.append('created_by_username', req.createdByUsername);
+    }
+    const query = params.toString();
+    const fullUrl = query !== '' ? `${url}?${query}` : url;
+    let resp: ListTokensRequest_Response | undefined;
+    const call: Call = async (callSignal?: AbortSignal): Promise<void> => {
+      const headers = new Headers();
+      if (this.workspaceId !== undefined) {
+        headers.set('X-Databricks-Org-Id', this.workspaceId);
+      }
+      headers.set('User-Agent', this.userAgent);
+      const httpReq = buildHttpRequest('GET', fullUrl, headers, callSignal);
+      const respBody = await executeHttpCall({
+        request: httpReq,
+        httpClient: this.httpClient,
+        logger: this.logger,
+      });
+      resp = parseResponse(respBody, unmarshalListTokensRequest_ResponseSchema);
+    };
+    await executeCall(call, options);
+    if (resp === undefined) {
+      throw new Error('API call completed without a result.');
+    }
+    return resp;
+  }
+
+  /** Updates a token, specified by its ID. */
+  async updateToken(
+    req: UpdateToken,
+    options?: CallOptions
+  ): Promise<AdminTokenInfo> {
+    const url = `${this.host}/api/2.0/token-management/tokens/${req.token?.tokenId ?? ''}`;
+    const body = marshalRequest(req, marshalUpdateTokenSchema);
+    let resp: AdminTokenInfo | undefined;
+    const call: Call = async (callSignal?: AbortSignal): Promise<void> => {
+      const headers = new Headers({'Content-Type': 'application/json'});
+      if (this.workspaceId !== undefined) {
+        headers.set('X-Databricks-Org-Id', this.workspaceId);
+      }
+      headers.set('User-Agent', this.userAgent);
+      const httpReq = buildHttpRequest('PATCH', url, headers, callSignal, body);
+      const respBody = await executeHttpCall({
+        request: httpReq,
+        httpClient: this.httpClient,
+        logger: this.logger,
+      });
+      resp = parseResponse(respBody, unmarshalAdminTokenInfoSchema);
+    };
+    await executeCall(call, options);
+    if (resp === undefined) {
+      throw new Error('API call completed without a result.');
+    }
+    return resp;
+  }
+}

package/src/v1/index.ts

@@ -0,0 +1,20 @@
+// Code generated from API definition by Databricks SDK Generator. DO NOT EDIT.
+
+export {TokenmanagementClient} from './client';
+
+export {AutoscopeState} from './model';
+
+export type {
+  AdminTokenInfo,
+  CreateOnBehalfOfTokenRequest,
+  CreateOnBehalfOfTokenRequest_Response,
+  GetTokenRequest,
+  GetTokenRequest_Response,
+  ListTokensRequest,
+  ListTokensRequest_Response,
+  RevokeTokenRequest,
+  RevokeTokenRequest_Response,
+  UpdateToken,
+} from './model';
+
+export {adminTokenInfoFieldMask} from './model';

package/src/v1/model.ts

@@ -0,0 +1,301 @@
+// Code generated from API definition by Databricks SDK Generator. DO NOT EDIT.
+
+import {FieldMask} from '@databricks/sdk-core/wkt';
+import type {FieldMaskSchema} from '@databricks/sdk-core/wkt';
+import {z} from 'zod';
+
+/**
+ * State of inferred scope collection (autoscope) for an external PAT.
+ * Mirrored in databricks.identity.AutoscopeState in common/principal-context/api/proto/tokendetails.proto.
+ * Token store and token management proto can depend on this.
+ * Principal context proto should NOT depend on this proto definitions because too many services depend on the principal context proto.
+ */
+export enum AutoscopeState {
+  AUTOSCOPE_STATE_UNSPECIFIED = 'AUTOSCOPE_STATE_UNSPECIFIED',
+  AUTOSCOPE_STATE_DISABLED = 'AUTOSCOPE_STATE_DISABLED',
+  AUTOSCOPE_STATE_RUNNING = 'AUTOSCOPE_STATE_RUNNING',
+  AUTOSCOPE_STATE_COMPLETED = 'AUTOSCOPE_STATE_COMPLETED',
+  AUTOSCOPE_STATE_BACKFILLED = 'AUTOSCOPE_STATE_BACKFILLED',
+  AUTOSCOPE_STATE_USER_SELECTED = 'AUTOSCOPE_STATE_USER_SELECTED',
+  AUTOSCOPE_STATE_API_NOT_COVERED = 'AUTOSCOPE_STATE_API_NOT_COVERED',
+}
+
+export interface AdminTokenInfo {
+  /** ID of the token. */
+  tokenId?: string | undefined;
+  /** Timestamp when the token was created. */
+  creationTime?: bigint | undefined;
+  /** Timestamp when the token expires. */
+  expiryTime?: bigint | undefined;
+  /** Comment that describes the purpose of the token, specified by the token creator. */
+  comment?: string | undefined;
+  /** User ID of the user that created the token. */
+  createdById?: bigint | undefined;
+  /** Username of the user that created the token. */
+  createdByUsername?: string | undefined;
+  /** User ID of the user that owns the token. */
+  ownerId?: bigint | undefined;
+  /** If applicable, the ID of the workspace that the token was created in. */
+  workspaceId?: bigint | undefined;
+  /** Approximate timestamp for the day the token was last used. Accurate up to 1 day. */
+  lastUsedDay?: bigint | undefined;
+  /** Scope of the token was created with, if applicable. */
+  scopes?: string[] | undefined;
+  /** Output only. The autoscope state of this token. */
+  autoscopeState?: AutoscopeState | undefined;
+  /** Output only. Inferred API path scopes collected for this token when autoscope is enabled. */
+  inferredScopes?: string[] | undefined;
+  /** Output only. Scopes inferred from offline backfill processing. */
+  backfillScopes?: string[] | undefined;
+}
+
+/** Configuration details for creating on-behalf tokens. */
+export interface CreateOnBehalfOfTokenRequest {
+  /** Application ID of the service principal. */
+  applicationId?: string | undefined;
+  /** The number of seconds before the token expires. */
+  lifetimeSeconds?: bigint | undefined;
+  /** Comment that describes the purpose of the token. */
+  comment?: string | undefined;
+  scopes?: string[] | undefined;
+  /** Whether to enable autoscoping for this token. */
+  autoscopeEnabled?: boolean | undefined;
+}
+
+/** An on-behalf token was successfully created for the service principal. */
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export interface CreateOnBehalfOfTokenRequest_Response {
+  /** Value of the token. */
+  tokenValue?: string | undefined;
+  tokenInfo?: AdminTokenInfo | undefined;
+}
+
+/**
+ * !! KEEP THIS IN-SYNC WITH THE WORKSPACE PROTO DEFINITIONS IN SERVICE.PROTO !!
+ *
+ * The only differences should be:
+ * 1. The OpenAPI labels.
+ * 2. The account_id request parameter.
+ */
+export interface GetTokenRequest {
+  /** The ID of the token to get. */
+  tokenId?: string | undefined;
+}
+
+/** Token with specified Token ID was successfully returned. */
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export interface GetTokenRequest_Response {
+  tokenInfo?: AdminTokenInfo | undefined;
+}
+
+/**
+ * !! KEEP THIS IN-SYNC WITH THE ACCOUNT PROTO DEFINITIONS IN ACCOUNT_SERVICE.PROTO !!
+ *
+ * The only differences should be:
+ * 1. The OpenAPI labels.
+ * 2. The account_id request parameter.
+ * 3. The string filter parameter instead of hard-coded filters.
+ */
+export interface ListTokensRequest {
+  /** User ID of the user that created the token. */
+  createdById?: bigint | undefined;
+  /** Username of the user that created the token. */
+  createdByUsername?: string | undefined;
+}
+
+/** Tokens were successfully returned. */
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export interface ListTokensRequest_Response {
+  /** Token metadata of each user-created token in the workspace */
+  tokenInfos?: AdminTokenInfo[] | undefined;
+}
+
+export interface RevokeTokenRequest {
+  /** The ID of the token to revoke. */
+  tokenId?: string | undefined;
+}
+
+/** The token was successfully deleted. */
+// eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-empty-object-type -- Proto-style nested message name.
+export interface RevokeTokenRequest_Response {}
+
+/**
+ * For the list of supported token scopes, see
+ * https://docs.databricks.com/api/workspace/api/scopes.
+ */
+export interface UpdateToken {
+  token?: AdminTokenInfo | undefined;
+  /** A list of field name under token, For example, {"update_mask": "comment,scopes"} */
+  updateMask?: FieldMask<AdminTokenInfo> | undefined;
+}
+
+export const unmarshalAdminTokenInfoSchema: z.ZodType<AdminTokenInfo> = z
+  .object({
+    token_id: z.string().optional(),
+    creation_time: z
+      .union([z.number(), z.bigint()])
+      .transform(v => BigInt(v))
+      .optional(),
+    expiry_time: z
+      .union([z.number(), z.bigint()])
+      .transform(v => BigInt(v))
+      .optional(),
+    comment: z.string().optional(),
+    created_by_id: z
+      .union([z.number(), z.bigint()])
+      .transform(v => BigInt(v))
+      .optional(),
+    created_by_username: z.string().optional(),
+    owner_id: z
+      .union([z.number(), z.bigint()])
+      .transform(v => BigInt(v))
+      .optional(),
+    workspace_id: z
+      .union([z.number(), z.bigint()])
+      .transform(v => BigInt(v))
+      .optional(),
+    last_used_day: z
+      .union([z.number(), z.bigint()])
+      .transform(v => BigInt(v))
+      .optional(),
+    scopes: z.array(z.string()).optional(),
+    autoscope_state: z.enum(AutoscopeState).optional(),
+    inferred_scopes: z.array(z.string()).optional(),
+    backfill_scopes: z.array(z.string()).optional(),
+  })
+  .transform(d => ({
+    tokenId: d.token_id,
+    creationTime: d.creation_time,
+    expiryTime: d.expiry_time,
+    comment: d.comment,
+    createdById: d.created_by_id,
+    createdByUsername: d.created_by_username,
+    ownerId: d.owner_id,
+    workspaceId: d.workspace_id,
+    lastUsedDay: d.last_used_day,
+    scopes: d.scopes,
+    autoscopeState: d.autoscope_state,
+    inferredScopes: d.inferred_scopes,
+    backfillScopes: d.backfill_scopes,
+  }));
+
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalCreateOnBehalfOfTokenRequest_ResponseSchema: z.ZodType<CreateOnBehalfOfTokenRequest_Response> =
+  z
+    .object({
+      token_value: z.string().optional(),
+      token_info: z.lazy(() => unmarshalAdminTokenInfoSchema).optional(),
+    })
+    .transform(d => ({
+      tokenValue: d.token_value,
+      tokenInfo: d.token_info,
+    }));
+
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalGetTokenRequest_ResponseSchema: z.ZodType<GetTokenRequest_Response> =
+  z
+    .object({
+      token_info: z.lazy(() => unmarshalAdminTokenInfoSchema).optional(),
+    })
+    .transform(d => ({
+      tokenInfo: d.token_info,
+    }));
+
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalListTokensRequest_ResponseSchema: z.ZodType<ListTokensRequest_Response> =
+  z
+    .object({
+      token_infos: z
+        .array(z.lazy(() => unmarshalAdminTokenInfoSchema))
+        .optional(),
+    })
+    .transform(d => ({
+      tokenInfos: d.token_infos,
+    }));
+
+// eslint-disable-next-line @typescript-eslint/naming-convention -- Proto-style nested message name.
+export const unmarshalRevokeTokenRequest_ResponseSchema: z.ZodType<RevokeTokenRequest_Response> =
+  z.object({});
+
+export const marshalAdminTokenInfoSchema: z.ZodType = z
+  .object({
+    tokenId: z.string().optional(),
+    creationTime: z.bigint().optional(),
+    expiryTime: z.bigint().optional(),
+    comment: z.string().optional(),
+    createdById: z.bigint().optional(),
+    createdByUsername: z.string().optional(),
+    ownerId: z.bigint().optional(),
+    workspaceId: z.bigint().optional(),
+    lastUsedDay: z.bigint().optional(),
+    scopes: z.array(z.string()).optional(),
+    autoscopeState: z.enum(AutoscopeState).optional(),
+    inferredScopes: z.array(z.string()).optional(),
+    backfillScopes: z.array(z.string()).optional(),
+  })
+  .transform(d => ({
+    token_id: d.tokenId,
+    creation_time: d.creationTime,
+    expiry_time: d.expiryTime,
+    comment: d.comment,
+    created_by_id: d.createdById,
+    created_by_username: d.createdByUsername,
+    owner_id: d.ownerId,
+    workspace_id: d.workspaceId,
+    last_used_day: d.lastUsedDay,
+    scopes: d.scopes,
+    autoscope_state: d.autoscopeState,
+    inferred_scopes: d.inferredScopes,
+    backfill_scopes: d.backfillScopes,
+  }));
+
+export const marshalCreateOnBehalfOfTokenRequestSchema: z.ZodType = z
+  .object({
+    applicationId: z.string().optional(),
+    lifetimeSeconds: z.bigint().optional(),
+    comment: z.string().optional(),
+    scopes: z.array(z.string()).optional(),
+    autoscopeEnabled: z.boolean().optional(),
+  })
+  .transform(d => ({
+    application_id: d.applicationId,
+    lifetime_seconds: d.lifetimeSeconds,
+    comment: d.comment,
+    scopes: d.scopes,
+    autoscope_enabled: d.autoscopeEnabled,
+  }));
+
+export const marshalUpdateTokenSchema: z.ZodType = z
+  .object({
+    token: z.lazy(() => marshalAdminTokenInfoSchema).optional(),
+    updateMask: z
+      .any()
+      .transform((m: FieldMask) => m.toString())
+      .optional(),
+  })
+  .transform(d => ({
+    token: d.token,
+    update_mask: d.updateMask,
+  }));
+
+const adminTokenInfoFieldMaskSchema: FieldMaskSchema = {
+  autoscopeState: {wire: 'autoscope_state'},
+  backfillScopes: {wire: 'backfill_scopes'},
+  comment: {wire: 'comment'},
+  createdById: {wire: 'created_by_id'},
+  createdByUsername: {wire: 'created_by_username'},
+  creationTime: {wire: 'creation_time'},
+  expiryTime: {wire: 'expiry_time'},
+  inferredScopes: {wire: 'inferred_scopes'},
+  lastUsedDay: {wire: 'last_used_day'},
+  ownerId: {wire: 'owner_id'},
+  scopes: {wire: 'scopes'},
+  tokenId: {wire: 'token_id'},
+  workspaceId: {wire: 'workspace_id'},
+};
+
+export function adminTokenInfoFieldMask(
+  ...paths: string[]
+): FieldMask<AdminTokenInfo> {
+  return FieldMask.build<AdminTokenInfo>(paths, adminTokenInfoFieldMaskSchema);
+}

package/src/v1/transport.ts

@@ -0,0 +1,73 @@
+// Code generated from API definition by Databricks SDK Generator. DO NOT EDIT.
+
+import type {Credentials} from '@databricks/sdk-auth';
+import {defaultCredentials} from '@databricks/sdk-auth/credentials';
+import type {
+  HttpClient,
+  HttpRequest,
+  HttpResponse,
+} from '@databricks/sdk-core/http';
+import {newFetchHttpClient} from '@databricks/sdk-core/http';
+import type {ClientOptions} from '@databricks/sdk-options/client';
+
+/** Creates a new HTTP client with the given options. */
+export function newHttpClient(options?: ClientOptions): HttpClient {
+  const opts = options ?? {};
+
+  // If an HTTP client is provided, use it as-is. Throw if other options are
+  // also set, since they would be silently ignored.
+  if (opts.httpClient !== undefined) {
+    if (opts.credentials !== undefined || opts.timeout !== undefined) {
+      throw new Error(
+        'httpClient cannot be combined with credentials or timeout'
+      );
+    }
+    return opts.httpClient;
+  }
+
+  const credentials = opts.credentials ?? defaultCredentials();
+
+  const base = newFetchHttpClient();
+  let client: HttpClient = new AuthHttpClient(base, credentials);
+
+  if (opts.timeout !== undefined) {
+    client = new TimeoutHttpClient(client, opts.timeout);
+  }
+
+  return client;
+}
+
+/** Wraps an HttpClient and adds authentication headers to requests. */
+class AuthHttpClient implements HttpClient {
+  constructor(
+    private readonly base: HttpClient,
+    private readonly credentials: Credentials
+  ) {}
+
+  async send(request: HttpRequest): Promise<HttpResponse> {
+    const authHeaders = await this.credentials.authHeaders();
+    // Do not modify the original request.
+    const headers = new Headers(request.headers);
+    for (const h of authHeaders) {
+      headers.set(h.key, h.value);
+    }
+    return this.base.send({...request, headers});
+  }
+}
+
+/** Wraps an HttpClient and applies a default timeout to requests. */
+class TimeoutHttpClient implements HttpClient {
+  constructor(
+    private readonly base: HttpClient,
+    private readonly timeout: number
+  ) {}
+
+  async send(request: HttpRequest): Promise<HttpResponse> {
+    const timeoutSignal = AbortSignal.timeout(this.timeout);
+    const signal =
+      request.signal !== undefined
+        ? AbortSignal.any([request.signal, timeoutSignal])
+        : timeoutSignal;
+    return this.base.send({...request, signal});
+  }
+}