@databricks/sdk-postgres 0.1.0-dev.5 → 0.2.0

package/dist/v1/client.js

@@ -2,7 +2,7 @@
 import { VERSION as AUTH_VERSION } from '@databricks/sdk-auth';
 import { createDefault } from '@databricks/sdk-core/clientinfo';
 import { NoOpLogger } from '@databricks/sdk-core/logger';
-import { newHttpClient } from './transport';
+import { resolveClientConfig } from './transport';
 import { buildHttpRequest, executeCall, executeHttpCall, marshalRequest, parseResponse, executeWait, StillRunningError, } from './utils';
 import pkgJson from '../../package.json' with { type: 'json' };
 import { z } from 'zod';
@@ -13,34 +13,33 @@ const PACKAGE_SEGMENT = {
     value: pkgJson.version,
 };
 export class PostgresClient {
-    host;
-    // 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.
-    workspaceId;
-    httpClient;
+    options;
     logger;
     // User-Agent header value. Composed once at construction from
     // createDefault() merged with this package's identity and the active
     // credential's name.
     userAgent;
+    // Memoized configuration. The profile is resolved once, lazily, on the first
+    // request, then reused; host, workspaceId/accountId, and credentials are
+    // filled from it when not set explicitly on the options.
+    config;
     constructor(options) {
-        if (options.host === undefined) {
-            throw new Error('Host is required.');
-        }
-        this.host = options.host.replace(/\/$/, '');
-        this.workspaceId = options.workspaceId;
+        this.options = options;
         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);
+    }
+    resolveConfig() {
+        this.config ??= resolveClientConfig(this.options);
+        return this.config;
     }
     /** Creates a new database branch in the project. */
-    async createBranch(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.parent ?? ''}/branches`;
+    async createBranchBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.parent ?? ''}/branches`;
         const params = new URLSearchParams();
         if (req.branchId !== undefined) {
             params.append('branch_id', req.branchId);
@@ -54,14 +53,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers({ 'Content-Type': 'application/json' });
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('POST', fullUrl, headers, callSignal, body);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -72,13 +71,15 @@ export class PostgresClient {
         }
         return resp;
     }
-    async createBranchOperation(req, options) {
-        const op = await this.createBranch(req, options);
+    /** Creates a new database branch in the project. */
+    async createBranch(req, options) {
+        const op = await this.createBranchBase(req, options);
         return new CreateBranchOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Register a Postgres database in the Unity Catalog. */
-    async createCatalog(req, options) {
-        const url = `${this.host}/api/2.0/postgres/catalogs`;
+    async createCatalogBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/catalogs`;
         const params = new URLSearchParams();
         if (req.catalogId !== undefined) {
             params.append('catalog_id', req.catalogId);
@@ -89,14 +90,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers({ 'Content-Type': 'application/json' });
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('POST', fullUrl, headers, callSignal, body);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -107,8 +108,9 @@ export class PostgresClient {
         }
         return resp;
     }
-    async createCatalogOperation(req, options) {
-        const op = await this.createCatalog(req, options);
+    /** Register a Postgres database in the Unity Catalog. */
+    async createCatalog(req, options) {
+        const op = await this.createCatalogBase(req, options);
         return new CreateCatalogOperation(op, (req, options) => this.getOperation(req, options));
     }
     /**
@@ -116,8 +118,9 @@ export class PostgresClient {
      *
      * Creates a database in the specified branch. A branch can have multiple databases.
      */
-    async createDatabase(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.parent ?? ''}/databases`;
+    async createDatabaseBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.parent ?? ''}/databases`;
         const params = new URLSearchParams();
         if (req.databaseId !== undefined) {
             params.append('database_id', req.databaseId);
@@ -128,14 +131,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers({ 'Content-Type': 'application/json' });
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('POST', fullUrl, headers, callSignal, body);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -146,13 +149,19 @@ export class PostgresClient {
         }
         return resp;
     }
-    async createDatabaseOperation(req, options) {
-        const op = await this.createDatabase(req, options);
+    /**
+     * Create a Database.
+     *
+     * Creates a database in the specified branch. A branch can have multiple databases.
+     */
+    async createDatabase(req, options) {
+        const op = await this.createDatabaseBase(req, options);
         return new CreateDatabaseOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Creates a new compute endpoint in the branch. */
-    async createEndpoint(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.parent ?? ''}/endpoints`;
+    async createEndpointBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.parent ?? ''}/endpoints`;
         const params = new URLSearchParams();
         if (req.endpointId !== undefined) {
             params.append('endpoint_id', req.endpointId);
@@ -166,14 +175,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers({ 'Content-Type': 'application/json' });
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('POST', fullUrl, headers, callSignal, body);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -184,13 +193,15 @@ export class PostgresClient {
         }
         return resp;
     }
-    async createEndpointOperation(req, options) {
-        const op = await this.createEndpoint(req, options);
+    /** Creates a new compute endpoint in the branch. */
+    async createEndpoint(req, options) {
+        const op = await this.createEndpointBase(req, options);
         return new CreateEndpointOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Creates a new Lakebase Autoscaling Postgres database project, which contains branches and compute endpoints. */
-    async createProject(req, options) {
-        const url = `${this.host}/api/2.0/postgres/projects`;
+    async createProjectBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/projects`;
         const params = new URLSearchParams();
         if (req.projectId !== undefined) {
             params.append('project_id', req.projectId);
@@ -201,14 +212,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers({ 'Content-Type': 'application/json' });
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('POST', fullUrl, headers, callSignal, body);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -219,13 +230,15 @@ export class PostgresClient {
         }
         return resp;
     }
-    async createProjectOperation(req, options) {
-        const op = await this.createProject(req, options);
+    /** Creates a new Lakebase Autoscaling Postgres database project, which contains branches and compute endpoints. */
+    async createProject(req, options) {
+        const op = await this.createProjectBase(req, options);
         return new CreateProjectOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Creates a new Postgres role in the branch. */
-    async createRole(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.parent ?? ''}/roles`;
+    async createRoleBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.parent ?? ''}/roles`;
         const params = new URLSearchParams();
         if (req.roleId !== undefined) {
             params.append('role_id', req.roleId);
@@ -236,14 +249,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers({ 'Content-Type': 'application/json' });
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('POST', fullUrl, headers, callSignal, body);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -254,13 +267,15 @@ export class PostgresClient {
         }
         return resp;
     }
-    async createRoleOperation(req, options) {
-        const op = await this.createRole(req, options);
+    /** Creates a new Postgres role in the branch. */
+    async createRole(req, options) {
+        const op = await this.createRoleBase(req, options);
         return new CreateRoleOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Create a Synced Table. */
-    async createSyncedTable(req, options) {
-        const url = `${this.host}/api/2.0/postgres/synced_tables`;
+    async createSyncedTableBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/synced_tables`;
         const params = new URLSearchParams();
         if (req.syncedTableId !== undefined) {
             params.append('synced_table_id', req.syncedTableId);
@@ -271,14 +286,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers({ 'Content-Type': 'application/json' });
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('POST', fullUrl, headers, callSignal, body);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -289,13 +304,15 @@ export class PostgresClient {
         }
         return resp;
     }
-    async createSyncedTableOperation(req, options) {
-        const op = await this.createSyncedTable(req, options);
+    /** Create a Synced Table. */
+    async createSyncedTable(req, options) {
+        const op = await this.createSyncedTableBase(req, options);
         return new CreateSyncedTableOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Deletes the specified database branch. */
-    async deleteBranch(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+    async deleteBranchBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}`;
         const params = new URLSearchParams();
         if (req.purge !== undefined) {
             params.append('purge', String(req.purge));
@@ -305,14 +322,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('DELETE', fullUrl, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -323,24 +340,26 @@ export class PostgresClient {
         }
         return resp;
     }
-    async deleteBranchOperation(req, options) {
-        const op = await this.deleteBranch(req, options);
+    /** Deletes the specified database branch. */
+    async deleteBranch(req, options) {
+        const op = await this.deleteBranchBase(req, options);
         return new DeleteBranchOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Delete a Database Catalog. */
-    async deleteCatalog(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+    async deleteCatalogBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}`;
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('DELETE', url, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -351,24 +370,26 @@ export class PostgresClient {
         }
         return resp;
     }
-    async deleteCatalogOperation(req, options) {
-        const op = await this.deleteCatalog(req, options);
+    /** Delete a Database Catalog. */
+    async deleteCatalog(req, options) {
+        const op = await this.deleteCatalogBase(req, options);
         return new DeleteCatalogOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Delete a Database. */
-    async deleteDatabase(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+    async deleteDatabaseBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}`;
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('DELETE', url, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -379,24 +400,26 @@ export class PostgresClient {
         }
         return resp;
     }
-    async deleteDatabaseOperation(req, options) {
-        const op = await this.deleteDatabase(req, options);
+    /** Delete a Database. */
+    async deleteDatabase(req, options) {
+        const op = await this.deleteDatabaseBase(req, options);
         return new DeleteDatabaseOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Deletes the specified compute endpoint. */
-    async deleteEndpoint(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+    async deleteEndpointBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}`;
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('DELETE', url, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -407,13 +430,15 @@ export class PostgresClient {
         }
         return resp;
     }
-    async deleteEndpointOperation(req, options) {
-        const op = await this.deleteEndpoint(req, options);
+    /** Deletes the specified compute endpoint. */
+    async deleteEndpoint(req, options) {
+        const op = await this.deleteEndpointBase(req, options);
         return new DeleteEndpointOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Deletes the specified database project. */
-    async deleteProject(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+    async deleteProjectBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}`;
         const params = new URLSearchParams();
         if (req.purge !== undefined) {
             params.append('purge', String(req.purge));
@@ -423,14 +448,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('DELETE', fullUrl, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -441,13 +466,15 @@ export class PostgresClient {
         }
         return resp;
     }
-    async deleteProjectOperation(req, options) {
-        const op = await this.deleteProject(req, options);
+    /** Deletes the specified database project. */
+    async deleteProject(req, options) {
+        const op = await this.deleteProjectBase(req, options);
         return new DeleteProjectOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Deletes the specified Postgres role. */
-    async deleteRole(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+    async deleteRoleBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}`;
         const params = new URLSearchParams();
         if (req.reassignOwnedTo !== undefined) {
             params.append('reassign_owned_to', req.reassignOwnedTo);
@@ -457,14 +484,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('DELETE', fullUrl, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -475,24 +502,26 @@ export class PostgresClient {
         }
         return resp;
     }
-    async deleteRoleOperation(req, options) {
-        const op = await this.deleteRole(req, options);
+    /** Deletes the specified Postgres role. */
+    async deleteRole(req, options) {
+        const op = await this.deleteRoleBase(req, options);
         return new DeleteRoleOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Delete a Synced Table. */
-    async deleteSyncedTable(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+    async deleteSyncedTableBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}`;
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('DELETE', url, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -503,25 +532,27 @@ export class PostgresClient {
         }
         return resp;
     }
-    async deleteSyncedTableOperation(req, options) {
-        const op = await this.deleteSyncedTable(req, options);
+    /** Delete a Synced Table. */
+    async deleteSyncedTable(req, options) {
+        const op = await this.deleteSyncedTableBase(req, options);
         return new DeleteSyncedTableOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Generate OAuth credentials for a Postgres database. */
     async generateDatabaseCredential(req, options) {
-        const url = `${this.host}/api/2.0/postgres/credentials`;
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/credentials`;
         const body = marshalRequest(req, marshalGenerateDatabaseCredentialRequestSchema);
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers({ 'Content-Type': 'application/json' });
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('POST', url, headers, callSignal, body);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalDatabaseCredentialSchema);
@@ -534,18 +565,19 @@ export class PostgresClient {
     }
     /** Retrieves information about the specified database branch. */
     async getBranch(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}`;
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('GET', url, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalBranchSchema);
@@ -558,18 +590,19 @@ export class PostgresClient {
     }
     /** Get a Database Catalog. */
     async getCatalog(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}`;
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('GET', url, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalCatalogSchema);
@@ -582,18 +615,19 @@ export class PostgresClient {
     }
     /** Get a Database. */
     async getDatabase(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}`;
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('GET', url, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalDatabaseSchema);
@@ -606,18 +640,19 @@ export class PostgresClient {
     }
     /** Retrieves information about the specified compute endpoint, including its connection details and operational state. */
     async getEndpoint(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}`;
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('GET', url, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalEndpointSchema);
@@ -630,18 +665,19 @@ export class PostgresClient {
     }
     /** Retrieves the status of a long-running operation. */
     async getOperation(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}`;
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('GET', url, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -654,18 +690,19 @@ export class PostgresClient {
     }
     /** Retrieves information about the specified database project. */
     async getProject(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}`;
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('GET', url, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalProjectSchema);
@@ -678,18 +715,19 @@ export class PostgresClient {
     }
     /** Retrieves information about the specified Postgres role, including its authentication method and permissions. */
     async getRole(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}`;
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('GET', url, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalRoleSchema);
@@ -702,18 +740,19 @@ export class PostgresClient {
     }
     /** Get a Synced Table. */
     async getSyncedTable(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}`;
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('GET', url, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalSyncedTableSchema);
@@ -726,7 +765,8 @@ export class PostgresClient {
     }
     /** Returns a paginated list of database branches in the project. */
     async listBranches(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.parent ?? ''}/branches`;
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.parent ?? ''}/branches`;
         const params = new URLSearchParams();
         if (req.pageToken !== undefined) {
             params.append('page_token', req.pageToken);
@@ -742,14 +782,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('GET', fullUrl, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalListBranchesResponseSchema);
@@ -775,7 +815,8 @@ export class PostgresClient {
     }
     /** List Databases. */
     async listDatabases(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.parent ?? ''}/databases`;
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.parent ?? ''}/databases`;
         const params = new URLSearchParams();
         if (req.pageToken !== undefined) {
             params.append('page_token', req.pageToken);
@@ -788,14 +829,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('GET', fullUrl, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalListDatabasesResponseSchema);
@@ -821,7 +862,8 @@ export class PostgresClient {
     }
     /** Returns a paginated list of compute endpoints in the branch. */
     async listEndpoints(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.parent ?? ''}/endpoints`;
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.parent ?? ''}/endpoints`;
         const params = new URLSearchParams();
         if (req.pageToken !== undefined) {
             params.append('page_token', req.pageToken);
@@ -834,14 +876,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('GET', fullUrl, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalListEndpointsResponseSchema);
@@ -867,7 +909,8 @@ export class PostgresClient {
     }
     /** Returns a paginated list of database projects in the workspace that the user has permission to access. */
     async listProjects(req, options) {
-        const url = `${this.host}/api/2.0/postgres/projects`;
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/projects`;
         const params = new URLSearchParams();
         if (req.pageToken !== undefined) {
             params.append('page_token', req.pageToken);
@@ -883,14 +926,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('GET', fullUrl, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalListProjectsResponseSchema);
@@ -916,7 +959,8 @@ export class PostgresClient {
     }
     /** Returns a paginated list of Postgres roles in the branch. */
     async listRoles(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.parent ?? ''}/roles`;
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.parent ?? ''}/roles`;
         const params = new URLSearchParams();
         if (req.pageToken !== undefined) {
             params.append('page_token', req.pageToken);
@@ -929,14 +973,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers();
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('GET', fullUrl, headers, callSignal);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalListRolesResponseSchema);
@@ -961,20 +1005,21 @@ export class PostgresClient {
         }
     }
     /** Undeletes the specified database branch. */
-    async undeleteBranch(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}/undelete`;
+    async undeleteBranchBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}/undelete`;
         const body = marshalRequest(req, marshalUndeleteBranchRequestSchema);
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers({ 'Content-Type': 'application/json' });
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('POST', url, headers, callSignal, body);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -985,25 +1030,27 @@ export class PostgresClient {
         }
         return resp;
     }
-    async undeleteBranchOperation(req, options) {
-        const op = await this.undeleteBranch(req, options);
+    /** Undeletes the specified database branch. */
+    async undeleteBranch(req, options) {
+        const op = await this.undeleteBranchBase(req, options);
         return new UndeleteBranchOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Undeletes a soft-deleted project. */
-    async undeleteProject(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}/undelete`;
+    async undeleteProjectBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.name ?? ''}/undelete`;
         const body = marshalRequest(req, marshalUndeleteProjectRequestSchema);
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers({ 'Content-Type': 'application/json' });
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('POST', url, headers, callSignal, body);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -1014,13 +1061,15 @@ export class PostgresClient {
         }
         return resp;
     }
-    async undeleteProjectOperation(req, options) {
-        const op = await this.undeleteProject(req, options);
+    /** Undeletes a soft-deleted project. */
+    async undeleteProject(req, options) {
+        const op = await this.undeleteProjectBase(req, options);
         return new UndeleteProjectOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Updates the specified database branch. You can set this branch as the project's default branch, or protect/unprotect it. */
-    async updateBranch(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.branch?.name ?? ''}`;
+    async updateBranchBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.branch?.name ?? ''}`;
         const params = new URLSearchParams();
         if (req.updateMask !== undefined) {
             params.append('update_mask', req.updateMask.toString());
@@ -1031,14 +1080,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers({ 'Content-Type': 'application/json' });
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('PATCH', fullUrl, headers, callSignal, body);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -1049,13 +1098,15 @@ export class PostgresClient {
         }
         return resp;
     }
-    async updateBranchOperation(req, options) {
-        const op = await this.updateBranch(req, options);
+    /** Updates the specified database branch. You can set this branch as the project's default branch, or protect/unprotect it. */
+    async updateBranch(req, options) {
+        const op = await this.updateBranchBase(req, options);
         return new UpdateBranchOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Update a Database. */
-    async updateDatabase(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.database?.name ?? ''}`;
+    async updateDatabaseBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.database?.name ?? ''}`;
         const params = new URLSearchParams();
         if (req.updateMask !== undefined) {
             params.append('update_mask', req.updateMask.toString());
@@ -1066,14 +1117,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers({ 'Content-Type': 'application/json' });
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('PATCH', fullUrl, headers, callSignal, body);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -1084,13 +1135,15 @@ export class PostgresClient {
         }
         return resp;
     }
-    async updateDatabaseOperation(req, options) {
-        const op = await this.updateDatabase(req, options);
+    /** Update a Database. */
+    async updateDatabase(req, options) {
+        const op = await this.updateDatabaseBase(req, options);
         return new UpdateDatabaseOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Updates the specified compute endpoint. You can update autoscaling limits, suspend timeout, or enable/disable the compute endpoint. */
-    async updateEndpoint(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.endpoint?.name ?? ''}`;
+    async updateEndpointBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.endpoint?.name ?? ''}`;
         const params = new URLSearchParams();
         if (req.updateMask !== undefined) {
             params.append('update_mask', req.updateMask.toString());
@@ -1101,14 +1154,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers({ 'Content-Type': 'application/json' });
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('PATCH', fullUrl, headers, callSignal, body);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -1119,13 +1172,15 @@ export class PostgresClient {
         }
         return resp;
     }
-    async updateEndpointOperation(req, options) {
-        const op = await this.updateEndpoint(req, options);
+    /** Updates the specified compute endpoint. You can update autoscaling limits, suspend timeout, or enable/disable the compute endpoint. */
+    async updateEndpoint(req, options) {
+        const op = await this.updateEndpointBase(req, options);
         return new UpdateEndpointOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Updates the specified database project. */
-    async updateProject(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.project?.name ?? ''}`;
+    async updateProjectBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.project?.name ?? ''}`;
         const params = new URLSearchParams();
         if (req.updateMask !== undefined) {
             params.append('update_mask', req.updateMask.toString());
@@ -1136,14 +1191,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers({ 'Content-Type': 'application/json' });
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('PATCH', fullUrl, headers, callSignal, body);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -1154,13 +1209,15 @@ export class PostgresClient {
         }
         return resp;
     }
-    async updateProjectOperation(req, options) {
-        const op = await this.updateProject(req, options);
+    /** Updates the specified database project. */
+    async updateProject(req, options) {
+        const op = await this.updateProjectBase(req, options);
         return new UpdateProjectOperation(op, (req, options) => this.getOperation(req, options));
     }
     /** Update a role for a branch. */
-    async updateRole(req, options) {
-        const url = `${this.host}/api/2.0/postgres/${req.role?.name ?? ''}`;
+    async updateRoleBase(req, options) {
+        const { host, workspaceId, httpClient } = await this.resolveConfig();
+        const url = `${host}/api/2.0/postgres/${req.role?.name ?? ''}`;
         const params = new URLSearchParams();
         if (req.updateMask !== undefined) {
             params.append('update_mask', req.updateMask.toString());
@@ -1171,14 +1228,14 @@ export class PostgresClient {
         let resp;
         const call = async (callSignal) => {
             const headers = new Headers({ 'Content-Type': 'application/json' });
-            if (this.workspaceId !== undefined) {
-                headers.set('X-Databricks-Org-Id', this.workspaceId);
+            if (workspaceId !== undefined) {
+                headers.set('X-Databricks-Org-Id', workspaceId);
             }
             headers.set('User-Agent', this.userAgent);
             const httpReq = buildHttpRequest('PATCH', fullUrl, headers, callSignal, body);
             const respBody = await executeHttpCall({
                 request: httpReq,
-                httpClient: this.httpClient,
+                httpClient,
                 logger: this.logger,
             });
             resp = parseResponse(respBody, unmarshalOperationSchema);
@@ -1189,8 +1246,9 @@ export class PostgresClient {
         }
         return resp;
     }
-    async updateRoleOperation(req, options) {
-        const op = await this.updateRole(req, options);
+    /** Update a role for a branch. */
+    async updateRole(req, options) {
+        const op = await this.updateRoleBase(req, options);
         return new UpdateRoleOperation(op, (req, options) => this.getOperation(req, options));
     }
 }