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

package/dist/v1/client.js

@@ -0,0 +1,2654 @@
+// Code generated from API definition by Databricks SDK Generator. DO NOT EDIT.
+import { VERSION as AUTH_VERSION } from '@databricks/sdk-auth';
+import { retryOn } from '@databricks/sdk-core/api';
+import { createDefault } from '@databricks/sdk-core/clientinfo';
+import { NoOpLogger } from '@databricks/sdk-core/logger';
+import { newHttpClient } from './transport';
+import { buildHttpRequest, executeCall, executeHttpCall, marshalRequest, parseResponse, } from './utils';
+import pkgJson from '../../package.json' with { type: 'json' };
+import { z } from 'zod';
+import { marshalBranchSchema, marshalCatalogSchema, marshalDatabaseSchema, marshalEndpointSchema, marshalGenerateDatabaseCredentialRequestSchema, marshalProjectSchema, marshalRoleSchema, marshalSyncedTableSchema, marshalUndeleteBranchRequestSchema, marshalUndeleteProjectRequestSchema, unmarshalBranchOperationMetadataSchema, unmarshalBranchSchema, unmarshalCatalogOperationMetadataSchema, unmarshalCatalogSchema, unmarshalDatabaseCredentialSchema, unmarshalDatabaseOperationMetadataSchema, unmarshalDatabaseSchema, unmarshalEndpointOperationMetadataSchema, unmarshalEndpointSchema, unmarshalListBranchesResponseSchema, unmarshalListDatabasesResponseSchema, unmarshalListEndpointsResponseSchema, unmarshalListProjectsResponseSchema, unmarshalListRolesResponseSchema, unmarshalOperationSchema, unmarshalProjectOperationMetadataSchema, unmarshalProjectSchema, unmarshalRoleOperationMetadataSchema, unmarshalRoleSchema, unmarshalSyncedTableOperationMetadataSchema, unmarshalSyncedTableSchema, } 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 Client {
+    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;
+    logger;
+    // User-Agent header value. Composed once at construction from
+    // createDefault() merged with this package's identity and the active
+    // credential's name.
+    userAgent;
+    constructor(options) {
+        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();
+        let info = createDefault().with(PACKAGE_SEGMENT);
+        if (options.credentials !== undefined) {
+            info = info
+                .with({ key: 'sdk-js-auth', value: AUTH_VERSION })
+                .with({ key: 'auth', value: options.credentials.name() });
+        }
+        this.userAgent = info.toString();
+        this.httpClient = newHttpClient(options);
+    }
+    /** Creates a new database branch in the project. */
+    async createBranch(req, options) {
+        const url = `${this.host}/api/2.0/postgres/${req.parent ?? ''}/branches`;
+        const params = new URLSearchParams();
+        if (req.branchId !== undefined) {
+            params.append('branch_id', req.branchId);
+        }
+        if (req.replaceExisting !== undefined) {
+            params.append('replace_existing', String(req.replaceExisting));
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        const body = marshalRequest(req.branch, marshalBranchSchema);
+        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);
+            }
+            headers.set('User-Agent', this.userAgent);
+            const httpReq = buildHttpRequest('POST', fullUrl, headers, callSignal, body);
+            const respBody = await executeHttpCall({
+                request: httpReq,
+                httpClient: this.httpClient,
+                logger: this.logger,
+            });
+            resp = parseResponse(respBody, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async createBranchOperation(req, options) {
+        const op = await this.createBranch(req, options);
+        return new CreateBranchOperation(this, op);
+    }
+    /** Register a Postgres database in the Unity Catalog. */
+    async createCatalog(req, options) {
+        const url = `${this.host}/api/2.0/postgres/catalogs`;
+        const params = new URLSearchParams();
+        if (req.catalogId !== undefined) {
+            params.append('catalog_id', req.catalogId);
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        const body = marshalRequest(req.catalog, marshalCatalogSchema);
+        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);
+            }
+            headers.set('User-Agent', this.userAgent);
+            const httpReq = buildHttpRequest('POST', fullUrl, headers, callSignal, body);
+            const respBody = await executeHttpCall({
+                request: httpReq,
+                httpClient: this.httpClient,
+                logger: this.logger,
+            });
+            resp = parseResponse(respBody, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async createCatalogOperation(req, options) {
+        const op = await this.createCatalog(req, options);
+        return new CreateCatalogOperation(this, op);
+    }
+    /**
+     * Create a Database.
+     *
+     * 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`;
+        const params = new URLSearchParams();
+        if (req.databaseId !== undefined) {
+            params.append('database_id', req.databaseId);
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        const body = marshalRequest(req.database, marshalDatabaseSchema);
+        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);
+            }
+            headers.set('User-Agent', this.userAgent);
+            const httpReq = buildHttpRequest('POST', fullUrl, headers, callSignal, body);
+            const respBody = await executeHttpCall({
+                request: httpReq,
+                httpClient: this.httpClient,
+                logger: this.logger,
+            });
+            resp = parseResponse(respBody, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async createDatabaseOperation(req, options) {
+        const op = await this.createDatabase(req, options);
+        return new CreateDatabaseOperation(this, op);
+    }
+    /** Creates a new compute endpoint in the branch. */
+    async createEndpoint(req, options) {
+        const url = `${this.host}/api/2.0/postgres/${req.parent ?? ''}/endpoints`;
+        const params = new URLSearchParams();
+        if (req.endpointId !== undefined) {
+            params.append('endpoint_id', req.endpointId);
+        }
+        if (req.replaceExisting !== undefined) {
+            params.append('replace_existing', String(req.replaceExisting));
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        const body = marshalRequest(req.endpoint, marshalEndpointSchema);
+        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);
+            }
+            headers.set('User-Agent', this.userAgent);
+            const httpReq = buildHttpRequest('POST', fullUrl, headers, callSignal, body);
+            const respBody = await executeHttpCall({
+                request: httpReq,
+                httpClient: this.httpClient,
+                logger: this.logger,
+            });
+            resp = parseResponse(respBody, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async createEndpointOperation(req, options) {
+        const op = await this.createEndpoint(req, options);
+        return new CreateEndpointOperation(this, op);
+    }
+    /** 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`;
+        const params = new URLSearchParams();
+        if (req.projectId !== undefined) {
+            params.append('project_id', req.projectId);
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        const body = marshalRequest(req.project, marshalProjectSchema);
+        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);
+            }
+            headers.set('User-Agent', this.userAgent);
+            const httpReq = buildHttpRequest('POST', fullUrl, headers, callSignal, body);
+            const respBody = await executeHttpCall({
+                request: httpReq,
+                httpClient: this.httpClient,
+                logger: this.logger,
+            });
+            resp = parseResponse(respBody, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async createProjectOperation(req, options) {
+        const op = await this.createProject(req, options);
+        return new CreateProjectOperation(this, op);
+    }
+    /** Creates a new Postgres role in the branch. */
+    async createRole(req, options) {
+        const url = `${this.host}/api/2.0/postgres/${req.parent ?? ''}/roles`;
+        const params = new URLSearchParams();
+        if (req.roleId !== undefined) {
+            params.append('role_id', req.roleId);
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        const body = marshalRequest(req.role, marshalRoleSchema);
+        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);
+            }
+            headers.set('User-Agent', this.userAgent);
+            const httpReq = buildHttpRequest('POST', fullUrl, headers, callSignal, body);
+            const respBody = await executeHttpCall({
+                request: httpReq,
+                httpClient: this.httpClient,
+                logger: this.logger,
+            });
+            resp = parseResponse(respBody, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async createRoleOperation(req, options) {
+        const op = await this.createRole(req, options);
+        return new CreateRoleOperation(this, op);
+    }
+    /** Create a Synced Table. */
+    async createSyncedTable(req, options) {
+        const url = `${this.host}/api/2.0/postgres/synced_tables`;
+        const params = new URLSearchParams();
+        if (req.syncedTableId !== undefined) {
+            params.append('synced_table_id', req.syncedTableId);
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        const body = marshalRequest(req.syncedTable, marshalSyncedTableSchema);
+        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);
+            }
+            headers.set('User-Agent', this.userAgent);
+            const httpReq = buildHttpRequest('POST', fullUrl, headers, callSignal, body);
+            const respBody = await executeHttpCall({
+                request: httpReq,
+                httpClient: this.httpClient,
+                logger: this.logger,
+            });
+            resp = parseResponse(respBody, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async createSyncedTableOperation(req, options) {
+        const op = await this.createSyncedTable(req, options);
+        return new CreateSyncedTableOperation(this, op);
+    }
+    /** Deletes the specified database branch. */
+    async deleteBranch(req, options) {
+        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+        const params = new URLSearchParams();
+        if (req.purge !== undefined) {
+            params.append('purge', String(req.purge));
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        let resp;
+        const call = async (callSignal) => {
+            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', fullUrl, headers, callSignal);
+            const respBody = await executeHttpCall({
+                request: httpReq,
+                httpClient: this.httpClient,
+                logger: this.logger,
+            });
+            resp = parseResponse(respBody, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async deleteBranchOperation(req, options) {
+        const op = await this.deleteBranch(req, options);
+        return new DeleteBranchOperation(this, op);
+    }
+    /** Delete a Database Catalog. */
+    async deleteCatalog(req, options) {
+        const url = `${this.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);
+            }
+            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, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async deleteCatalogOperation(req, options) {
+        const op = await this.deleteCatalog(req, options);
+        return new DeleteCatalogOperation(this, op);
+    }
+    /** Delete a Database. */
+    async deleteDatabase(req, options) {
+        const url = `${this.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);
+            }
+            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, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async deleteDatabaseOperation(req, options) {
+        const op = await this.deleteDatabase(req, options);
+        return new DeleteDatabaseOperation(this, op);
+    }
+    /** Deletes the specified compute endpoint. */
+    async deleteEndpoint(req, options) {
+        const url = `${this.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);
+            }
+            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, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async deleteEndpointOperation(req, options) {
+        const op = await this.deleteEndpoint(req, options);
+        return new DeleteEndpointOperation(this, op);
+    }
+    /** Deletes the specified database project. */
+    async deleteProject(req, options) {
+        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+        const params = new URLSearchParams();
+        if (req.purge !== undefined) {
+            params.append('purge', String(req.purge));
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        let resp;
+        const call = async (callSignal) => {
+            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', fullUrl, headers, callSignal);
+            const respBody = await executeHttpCall({
+                request: httpReq,
+                httpClient: this.httpClient,
+                logger: this.logger,
+            });
+            resp = parseResponse(respBody, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async deleteProjectOperation(req, options) {
+        const op = await this.deleteProject(req, options);
+        return new DeleteProjectOperation(this, op);
+    }
+    /** Deletes the specified Postgres role. */
+    async deleteRole(req, options) {
+        const url = `${this.host}/api/2.0/postgres/${req.name ?? ''}`;
+        const params = new URLSearchParams();
+        if (req.reassignOwnedTo !== undefined) {
+            params.append('reassign_owned_to', req.reassignOwnedTo);
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        let resp;
+        const call = async (callSignal) => {
+            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', fullUrl, headers, callSignal);
+            const respBody = await executeHttpCall({
+                request: httpReq,
+                httpClient: this.httpClient,
+                logger: this.logger,
+            });
+            resp = parseResponse(respBody, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async deleteRoleOperation(req, options) {
+        const op = await this.deleteRole(req, options);
+        return new DeleteRoleOperation(this, op);
+    }
+    /** Delete a Synced Table. */
+    async deleteSyncedTable(req, options) {
+        const url = `${this.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);
+            }
+            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, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async deleteSyncedTableOperation(req, options) {
+        const op = await this.deleteSyncedTable(req, options);
+        return new DeleteSyncedTableOperation(this, op);
+    }
+    /** Generate OAuth credentials for a Postgres database. */
+    async generateDatabaseCredential(req, options) {
+        const url = `${this.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);
+            }
+            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, unmarshalDatabaseCredentialSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    /** Retrieves information about the specified database branch. */
+    async getBranch(req, options) {
+        const url = `${this.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);
+            }
+            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, unmarshalBranchSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    /** Get a Database Catalog. */
+    async getCatalog(req, options) {
+        const url = `${this.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);
+            }
+            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, unmarshalCatalogSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    /** Get a Database. */
+    async getDatabase(req, options) {
+        const url = `${this.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);
+            }
+            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, unmarshalDatabaseSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    /** 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 ?? ''}`;
+        let resp;
+        const call = async (callSignal) => {
+            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, unmarshalEndpointSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    /** Retrieves the status of a long-running operation. */
+    async getOperation(req, options) {
+        const url = `${this.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);
+            }
+            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, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    /** Retrieves information about the specified database project. */
+    async getProject(req, options) {
+        const url = `${this.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);
+            }
+            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, unmarshalProjectSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    /** 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 ?? ''}`;
+        let resp;
+        const call = async (callSignal) => {
+            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, unmarshalRoleSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    /** Get a Synced Table. */
+    async getSyncedTable(req, options) {
+        const url = `${this.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);
+            }
+            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, unmarshalSyncedTableSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    /** 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 params = new URLSearchParams();
+        if (req.pageToken !== undefined) {
+            params.append('page_token', req.pageToken);
+        }
+        if (req.pageSize !== undefined) {
+            params.append('page_size', String(req.pageSize));
+        }
+        if (req.showDeleted !== undefined) {
+            params.append('show_deleted', String(req.showDeleted));
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        let resp;
+        const call = async (callSignal) => {
+            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, unmarshalListBranchesResponseSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async *listBranchesIter(req, options) {
+        const pageReq = { ...req };
+        for (;;) {
+            const resp = await this.listBranches(pageReq, options);
+            for (const item of resp.branches ?? []) {
+                yield item;
+            }
+            if (resp.nextPageToken === undefined || resp.nextPageToken === '') {
+                return;
+            }
+            pageReq.pageToken = resp.nextPageToken;
+        }
+    }
+    /** List Databases. */
+    async listDatabases(req, options) {
+        const url = `${this.host}/api/2.0/postgres/${req.parent ?? ''}/databases`;
+        const params = new URLSearchParams();
+        if (req.pageToken !== undefined) {
+            params.append('page_token', req.pageToken);
+        }
+        if (req.pageSize !== undefined) {
+            params.append('page_size', String(req.pageSize));
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        let resp;
+        const call = async (callSignal) => {
+            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, unmarshalListDatabasesResponseSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async *listDatabasesIter(req, options) {
+        const pageReq = { ...req };
+        for (;;) {
+            const resp = await this.listDatabases(pageReq, options);
+            for (const item of resp.databases ?? []) {
+                yield item;
+            }
+            if (resp.nextPageToken === undefined || resp.nextPageToken === '') {
+                return;
+            }
+            pageReq.pageToken = resp.nextPageToken;
+        }
+    }
+    /** 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 params = new URLSearchParams();
+        if (req.pageToken !== undefined) {
+            params.append('page_token', req.pageToken);
+        }
+        if (req.pageSize !== undefined) {
+            params.append('page_size', String(req.pageSize));
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        let resp;
+        const call = async (callSignal) => {
+            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, unmarshalListEndpointsResponseSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async *listEndpointsIter(req, options) {
+        const pageReq = { ...req };
+        for (;;) {
+            const resp = await this.listEndpoints(pageReq, options);
+            for (const item of resp.endpoints ?? []) {
+                yield item;
+            }
+            if (resp.nextPageToken === undefined || resp.nextPageToken === '') {
+                return;
+            }
+            pageReq.pageToken = resp.nextPageToken;
+        }
+    }
+    /** 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 params = new URLSearchParams();
+        if (req.pageToken !== undefined) {
+            params.append('page_token', req.pageToken);
+        }
+        if (req.pageSize !== undefined) {
+            params.append('page_size', String(req.pageSize));
+        }
+        if (req.showDeleted !== undefined) {
+            params.append('show_deleted', String(req.showDeleted));
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        let resp;
+        const call = async (callSignal) => {
+            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, unmarshalListProjectsResponseSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async *listProjectsIter(req, options) {
+        const pageReq = { ...req };
+        for (;;) {
+            const resp = await this.listProjects(pageReq, options);
+            for (const item of resp.projects ?? []) {
+                yield item;
+            }
+            if (resp.nextPageToken === undefined || resp.nextPageToken === '') {
+                return;
+            }
+            pageReq.pageToken = resp.nextPageToken;
+        }
+    }
+    /** 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 params = new URLSearchParams();
+        if (req.pageToken !== undefined) {
+            params.append('page_token', req.pageToken);
+        }
+        if (req.pageSize !== undefined) {
+            params.append('page_size', String(req.pageSize));
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        let resp;
+        const call = async (callSignal) => {
+            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, unmarshalListRolesResponseSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async *listRolesIter(req, options) {
+        const pageReq = { ...req };
+        for (;;) {
+            const resp = await this.listRoles(pageReq, options);
+            for (const item of resp.roles ?? []) {
+                yield item;
+            }
+            if (resp.nextPageToken === undefined || resp.nextPageToken === '') {
+                return;
+            }
+            pageReq.pageToken = resp.nextPageToken;
+        }
+    }
+    /** Undeletes the specified database branch. */
+    async undeleteBranch(req, options) {
+        const url = `${this.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);
+            }
+            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, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async undeleteBranchOperation(req, options) {
+        const op = await this.undeleteBranch(req, options);
+        return new UndeleteBranchOperation(this, op);
+    }
+    /** Undeletes a soft-deleted project. */
+    async undeleteProject(req, options) {
+        const url = `${this.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);
+            }
+            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, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async undeleteProjectOperation(req, options) {
+        const op = await this.undeleteProject(req, options);
+        return new UndeleteProjectOperation(this, op);
+    }
+    /** 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 ?? ''}`;
+        const params = new URLSearchParams();
+        if (req.updateMask !== undefined) {
+            params.append('update_mask', req.updateMask.toString());
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        const body = marshalRequest(req.branch, marshalBranchSchema);
+        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);
+            }
+            headers.set('User-Agent', this.userAgent);
+            const httpReq = buildHttpRequest('PATCH', fullUrl, headers, callSignal, body);
+            const respBody = await executeHttpCall({
+                request: httpReq,
+                httpClient: this.httpClient,
+                logger: this.logger,
+            });
+            resp = parseResponse(respBody, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async updateBranchOperation(req, options) {
+        const op = await this.updateBranch(req, options);
+        return new UpdateBranchOperation(this, op);
+    }
+    /** Update a Database. */
+    async updateDatabase(req, options) {
+        const url = `${this.host}/api/2.0/postgres/${req.database?.name ?? ''}`;
+        const params = new URLSearchParams();
+        if (req.updateMask !== undefined) {
+            params.append('update_mask', req.updateMask.toString());
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        const body = marshalRequest(req.database, marshalDatabaseSchema);
+        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);
+            }
+            headers.set('User-Agent', this.userAgent);
+            const httpReq = buildHttpRequest('PATCH', fullUrl, headers, callSignal, body);
+            const respBody = await executeHttpCall({
+                request: httpReq,
+                httpClient: this.httpClient,
+                logger: this.logger,
+            });
+            resp = parseResponse(respBody, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async updateDatabaseOperation(req, options) {
+        const op = await this.updateDatabase(req, options);
+        return new UpdateDatabaseOperation(this, op);
+    }
+    /** 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 ?? ''}`;
+        const params = new URLSearchParams();
+        if (req.updateMask !== undefined) {
+            params.append('update_mask', req.updateMask.toString());
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        const body = marshalRequest(req.endpoint, marshalEndpointSchema);
+        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);
+            }
+            headers.set('User-Agent', this.userAgent);
+            const httpReq = buildHttpRequest('PATCH', fullUrl, headers, callSignal, body);
+            const respBody = await executeHttpCall({
+                request: httpReq,
+                httpClient: this.httpClient,
+                logger: this.logger,
+            });
+            resp = parseResponse(respBody, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async updateEndpointOperation(req, options) {
+        const op = await this.updateEndpoint(req, options);
+        return new UpdateEndpointOperation(this, op);
+    }
+    /** Updates the specified database project. */
+    async updateProject(req, options) {
+        const url = `${this.host}/api/2.0/postgres/${req.project?.name ?? ''}`;
+        const params = new URLSearchParams();
+        if (req.updateMask !== undefined) {
+            params.append('update_mask', req.updateMask.toString());
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        const body = marshalRequest(req.project, marshalProjectSchema);
+        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);
+            }
+            headers.set('User-Agent', this.userAgent);
+            const httpReq = buildHttpRequest('PATCH', fullUrl, headers, callSignal, body);
+            const respBody = await executeHttpCall({
+                request: httpReq,
+                httpClient: this.httpClient,
+                logger: this.logger,
+            });
+            resp = parseResponse(respBody, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async updateProjectOperation(req, options) {
+        const op = await this.updateProject(req, options);
+        return new UpdateProjectOperation(this, op);
+    }
+    /** Update a role for a branch. */
+    async updateRole(req, options) {
+        const url = `${this.host}/api/2.0/postgres/${req.role?.name ?? ''}`;
+        const params = new URLSearchParams();
+        if (req.updateMask !== undefined) {
+            params.append('update_mask', req.updateMask.toString());
+        }
+        const query = params.toString();
+        const fullUrl = query !== '' ? `${url}?${query}` : url;
+        const body = marshalRequest(req.role, marshalRoleSchema);
+        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);
+            }
+            headers.set('User-Agent', this.userAgent);
+            const httpReq = buildHttpRequest('PATCH', fullUrl, headers, callSignal, body);
+            const respBody = await executeHttpCall({
+                request: httpReq,
+                httpClient: this.httpClient,
+                logger: this.logger,
+            });
+            resp = parseResponse(respBody, unmarshalOperationSchema);
+        };
+        await executeCall(call, options);
+        if (resp === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return resp;
+    }
+    async updateRoleOperation(req, options) {
+        const op = await this.updateRole(req, options);
+        return new UpdateRoleOperation(this, op);
+    }
+}
+export class CreateBranchOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalBranchOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        let result;
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+            if (op.result?.$case !== 'response') {
+                throw new Error('operation completed without a response');
+            }
+            result = z.lazy(() => unmarshalBranchSchema).parse(op.result.response);
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+        if (result === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return result;
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class CreateCatalogOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalCatalogOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        let result;
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+            if (op.result?.$case !== 'response') {
+                throw new Error('operation completed without a response');
+            }
+            result = z.lazy(() => unmarshalCatalogSchema).parse(op.result.response);
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+        if (result === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return result;
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class CreateDatabaseOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalDatabaseOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        let result;
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+            if (op.result?.$case !== 'response') {
+                throw new Error('operation completed without a response');
+            }
+            result = z.lazy(() => unmarshalDatabaseSchema).parse(op.result.response);
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+        if (result === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return result;
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class CreateEndpointOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalEndpointOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        let result;
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+            if (op.result?.$case !== 'response') {
+                throw new Error('operation completed without a response');
+            }
+            result = z.lazy(() => unmarshalEndpointSchema).parse(op.result.response);
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+        if (result === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return result;
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class CreateProjectOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalProjectOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        let result;
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+            if (op.result?.$case !== 'response') {
+                throw new Error('operation completed without a response');
+            }
+            result = z.lazy(() => unmarshalProjectSchema).parse(op.result.response);
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+        if (result === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return result;
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class CreateRoleOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalRoleOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        let result;
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+            if (op.result?.$case !== 'response') {
+                throw new Error('operation completed without a response');
+            }
+            result = z.lazy(() => unmarshalRoleSchema).parse(op.result.response);
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+        if (result === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return result;
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class CreateSyncedTableOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalSyncedTableOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        let result;
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+            if (op.result?.$case !== 'response') {
+                throw new Error('operation completed without a response');
+            }
+            result = z
+                .lazy(() => unmarshalSyncedTableSchema)
+                .parse(op.result.response);
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+        if (result === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return result;
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class DeleteBranchOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalBranchOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class DeleteCatalogOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalCatalogOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class DeleteDatabaseOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalDatabaseOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class DeleteEndpointOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalEndpointOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class DeleteProjectOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalProjectOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class DeleteRoleOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalRoleOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class DeleteSyncedTableOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalSyncedTableOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class UndeleteBranchOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalBranchOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class UndeleteProjectOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalProjectOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class UpdateBranchOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalBranchOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        let result;
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+            if (op.result?.$case !== 'response') {
+                throw new Error('operation completed without a response');
+            }
+            result = z.lazy(() => unmarshalBranchSchema).parse(op.result.response);
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+        if (result === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return result;
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class UpdateDatabaseOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalDatabaseOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        let result;
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+            if (op.result?.$case !== 'response') {
+                throw new Error('operation completed without a response');
+            }
+            result = z.lazy(() => unmarshalDatabaseSchema).parse(op.result.response);
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+        if (result === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return result;
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class UpdateEndpointOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalEndpointOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        let result;
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+            if (op.result?.$case !== 'response') {
+                throw new Error('operation completed without a response');
+            }
+            result = z.lazy(() => unmarshalEndpointSchema).parse(op.result.response);
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+        if (result === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return result;
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class UpdateProjectOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalProjectOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        let result;
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+            if (op.result?.$case !== 'response') {
+                throw new Error('operation completed without a response');
+            }
+            result = z.lazy(() => unmarshalProjectSchema).parse(op.result.response);
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+        if (result === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return result;
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+export class UpdateRoleOperation {
+    client;
+    operation;
+    constructor(client, operation) {
+        this.client = client;
+        this.operation = operation;
+    }
+    /** Returns the server-assigned name of the long-running operation. */
+    name() {
+        return Promise.resolve(this.operation.name);
+    }
+    /** Returns metadata associated with the long-running operation. */
+    metadata() {
+        if (this.operation.metadata === undefined) {
+            return Promise.resolve(undefined);
+        }
+        return Promise.resolve(z
+            .lazy(() => unmarshalRoleOperationMetadataSchema)
+            .parse(this.operation.metadata));
+    }
+    /**
+     * Polls the operation until it completes.
+     *
+     * Throws if the operation failed.
+     */
+    async wait(options) {
+        const errStillRunning = new Error('operation still in progress');
+        let result;
+        const call = async (callSignal) => {
+            const op = await this.client.getOperation({
+                name: this.operation.name,
+            }, { ...options, ...(callSignal !== undefined && { signal: callSignal }) });
+            this.operation = op;
+            if (op.done === undefined) {
+                throw new Error('operation is missing the done field');
+            }
+            if (!op.done) {
+                throw errStillRunning;
+            }
+            if (op.result?.$case === 'error') {
+                const err = op.result.error;
+                const msg = err.message !== undefined && err.message !== ''
+                    ? err.message
+                    : 'unknown error';
+                const errorMsg = err.errorCode !== undefined ? `[${err.errorCode}] ${msg}` : msg;
+                throw new Error(`operation failed: ${errorMsg}`, {
+                    cause: err,
+                });
+            }
+            if (op.result?.$case !== 'response') {
+                throw new Error('operation completed without a response');
+            }
+            result = z.lazy(() => unmarshalRoleSchema).parse(op.result.response);
+        };
+        const retryOptions = {
+            ...(options?.signal !== undefined && { signal: options.signal }),
+            retrier: () => retryOn({}, (err) => {
+                return err.message.includes('operation still in progress');
+            }),
+        };
+        await executeCall(call, retryOptions);
+        if (result === undefined) {
+            throw new Error('API call completed without a result.');
+        }
+        return result;
+    }
+    /** Checks whether the operation has completed */
+    async done(options) {
+        const op = await this.client.getOperation({ name: this.operation.name }, options);
+        this.operation = op;
+        return op.done;
+    }
+}
+//# sourceMappingURL=client.js.map