@mongodb-js/mcp-atlas-api-client 3.0.0-prerelease.1

package/dist/apiClient.js

@@ -0,0 +1,636 @@
+import createClient from "openapi-fetch";
+import { ApiClientError } from "./apiClientError.js";
+import { AuthProviderFactory } from "./auth/authProvider.js";
+const ATLAS_API_VERSION = "2025-03-12";
+const DEFAULT_SEND_TIMEOUT_MS = 5000;
+/**
+ * Allowlist of incoming MCP request header names that may be forwarded to outgoing
+ * Atlas API requests. Kept intentionally minimal to avoid propagating hop-by-hop
+ * headers (e.g. `host`, `content-length`), cookies, or other sensitive/irrelevant
+ * headers. Comparison is case-insensitive, so entries must be lowercase.
+ */
+const FORWARDABLE_REQUEST_HEADERS = new Set(["x-request-id"]);
+/** @public */
+export const defaultCreateApiClient = (options, logger) => {
+    return new ApiClient(options, logger);
+};
+export class ApiClient {
+    isAuthConfigured() {
+        return !!this.authProvider;
+    }
+    constructor(options, logger, authProvider) {
+        this.logger = logger;
+        this.options = {
+            baseUrl: options.baseUrl,
+            userAgent: options.userAgent,
+            supportsCurrentIpLookup: options.supportsCurrentIpLookup ?? true,
+        };
+        this.authProvider =
+            authProvider ??
+                AuthProviderFactory.create({
+                    apiBaseUrl: this.options.baseUrl,
+                    userAgent: this.options.userAgent,
+                    credentials: options.credentials ?? {},
+                    httpClient: options.httpClient,
+                }, logger);
+        this.client = createClient({
+            baseUrl: this.options.baseUrl,
+            headers: {
+                "User-Agent": this.options.userAgent,
+                Accept: `application/vnd.atlas.${ATLAS_API_VERSION}+json`,
+            },
+            fetch: options.httpClient.fetch,
+            Request: options.httpClient.Request,
+        });
+        if (this.authProvider) {
+            this.client.use(this.createAuthMiddleware());
+        }
+    }
+    createAuthMiddleware() {
+        return {
+            onRequest: async ({ request, schemaPath }) => {
+                if (schemaPath.startsWith("/api/private/unauth") || schemaPath.startsWith("/api/oauth")) {
+                    return undefined;
+                }
+                try {
+                    const authHeaders = (await this.authProvider?.getAuthHeaders()) ?? {};
+                    for (const [key, value] of Object.entries(authHeaders)) {
+                        request.headers.set(key, value);
+                    }
+                    return request;
+                }
+                catch {
+                    // ignore not available tokens, API will return 401
+                    return undefined;
+                }
+            },
+        };
+    }
+    async validateAuthConfig() {
+        await this.authProvider?.validate();
+    }
+    async close() {
+        await this.authProvider?.revoke();
+    }
+    /**
+     * Merges allowlisted headers from an optional `ApiClientRequestContext` into the
+     * provided request options. Only headers in `FORWARDABLE_REQUEST_HEADERS` with a
+     * string value are forwarded (e.g. `x-request-id`); all other incoming headers are
+     * ignored. Headers already present in `options` take precedence over those coming
+     * from the context. Used by the auto-generated Atlas API methods.
+     */
+    applyRequestContext(options, context) {
+        const contextHeaders = context?.requestInfo?.headers;
+        if (!contextHeaders) {
+            return options;
+        }
+        const forwardedHeaders = {};
+        for (const [name, value] of Object.entries(contextHeaders)) {
+            if (typeof value === "string" && FORWARDABLE_REQUEST_HEADERS.has(name.toLowerCase())) {
+                forwardedHeaders[name] = value;
+            }
+        }
+        if (Object.keys(forwardedHeaders).length === 0) {
+            return options;
+        }
+        const existingHeaders = options?.headers;
+        return {
+            ...options,
+            headers: { ...forwardedHeaders, ...existingHeaders },
+        };
+    }
+    get supportsCurrentIpLookup() {
+        return this.options.supportsCurrentIpLookup;
+    }
+    async getIpInfo() {
+        if (!this.supportsCurrentIpLookup) {
+            throw new Error("This deployment does not support current IP detection. Provide the IP addresses to allow explicitly.");
+        }
+        const authHeaders = (await this.authProvider?.getAuthHeaders()) ?? {};
+        const endpoint = "api/private/ipinfo";
+        const url = new URL(endpoint, this.options.baseUrl);
+        const response = await fetch(url, {
+            method: "GET",
+            headers: {
+                ...authHeaders,
+                Accept: "application/json",
+                "User-Agent": this.options.userAgent,
+            },
+        });
+        if (!response.ok) {
+            throw await ApiClientError.fromResponse(response);
+        }
+        return (await response.json());
+    }
+    async sendEvents(events, { signal = AbortSignal.timeout(DEFAULT_SEND_TIMEOUT_MS) } = {}) {
+        if (!this.authProvider) {
+            await this.sendUnauthEvents(events, signal);
+            return;
+        }
+        try {
+            await this.sendAuthEvents(events, signal);
+        }
+        catch (error) {
+            if (error instanceof ApiClientError) {
+                if (error.response.status !== 401) {
+                    throw error;
+                }
+            }
+            // send unauth events if any of the following are true:
+            // 1: the token is not valid (not ApiClientError)
+            // 2: if the api responded with 401 (ApiClientError with status 401)
+            await this.sendUnauthEvents(events, signal);
+        }
+    }
+    async sendAuthEvents(events, signal) {
+        const authHeaders = await this.authProvider?.getAuthHeaders();
+        if (!authHeaders) {
+            throw new Error("No access token available");
+        }
+        const authUrl = new URL("api/private/v1.0/telemetry/events", this.options.baseUrl);
+        const response = await fetch(authUrl, {
+            method: "POST",
+            headers: {
+                ...authHeaders,
+                Accept: "application/json",
+                "Content-Type": "application/json",
+                "User-Agent": this.options.userAgent,
+            },
+            body: JSON.stringify(events),
+            signal,
+        });
+        if (!response.ok) {
+            throw await ApiClientError.fromResponse(response);
+        }
+    }
+    async sendUnauthEvents(events, signal) {
+        const headers = {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            "User-Agent": this.options.userAgent,
+        };
+        const unauthUrl = new URL("api/private/unauth/telemetry/events", this.options.baseUrl);
+        const response = await fetch(unauthUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(events),
+            signal,
+        });
+        if (!response.ok) {
+            throw await ApiClientError.fromResponse(response);
+        }
+    }
+    // DO NOT EDIT. This is auto-generated code.
+    /* eslint-disable @typescript-eslint/no-unsafe-assignment */
+    async listClusterDetails(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/clusters", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async listGroups(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async createGroup(options, context) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async deleteGroup(options, context) {
+        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    async getGroup(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async listAccessListEntries(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/accessList", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async createAccessListEntry(options, context) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/accessList", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async deleteAccessListEntry(options, context) {
+        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}/accessList/{entryValue}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    async listAlerts(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/alerts", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async createCloudProviderAccess(options, context) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/cloudProviderAccess", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async authorizeProviderAccessRole(options, context) {
+        const { data, error, response } = await this.client.PATCH("/api/atlas/v2/groups/{groupId}/cloudProviderAccess/{roleId}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async listClusters(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/clusters", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async createCluster(options, context) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/clusters", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async upgradeTenantUpgrade(options, context) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/clusters/tenantUpgrade", this.applyRequestContext({ ...options, headers: { Accept: "application/vnd.atlas.2023-01-01+json", ...options?.headers } }, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async deleteCluster(options, context) {
+        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}/clusters/{clusterName}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    async getCluster(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/clusters/{clusterName}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async updateCluster(options, context) {
+        const { data, error, response } = await this.client.PATCH("/api/atlas/v2/groups/{groupId}/clusters/{clusterName}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async listDropIndexSuggestions(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/performanceAdvisor/dropIndexSuggestions", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async listSchemaAdvice(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/performanceAdvisor/schemaAdvice", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async listClusterSuggestedIndexes(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/performanceAdvisor/suggestedIndexes", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async listDatabaseUsers(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/databaseUsers", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async createDatabaseUser(options, context) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/databaseUsers", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async deleteDatabaseUser(options, context) {
+        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}/databaseUsers/{databaseName}/{username}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    async getEncryptionAtRest(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/encryptionAtRest", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async updateEncryptionAtRest(options, context) {
+        const { data, error, response } = await this.client.PATCH("/api/atlas/v2/groups/{groupId}/encryptionAtRest", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async listFlexClusters(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/flexClusters", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async createFlexCluster(options, context) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/flexClusters", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async deleteFlexCluster(options, context) {
+        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}/flexClusters/{name}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    async getFlexCluster(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/flexClusters/{name}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async tenantUpgrade(options, context) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/flexClusters:tenantUpgrade", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async listSlowQueryLogs(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/processes/{processId}/performanceAdvisor/slowQueryLogs", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async requestSampleDatasetLoad(options, context) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/sampleDatasetLoad/{name}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async getSampleDatasetLoad(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/sampleDatasetLoad/{sampleDatasetId}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async listStreamWorkspaces(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/streams", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async createStreamWorkspace(options, context) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/streams", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async getAccountDetails(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/streams/accountDetails", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async listPrivateLinkConnections(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/streams/privateLinkConnections", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async createPrivateLinkConnection(options, context) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/streams/privateLinkConnections", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async deletePrivateLinkConnection(options, context) {
+        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}/streams/privateLinkConnections/{connectionId}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    async getPrivateLinkConnection(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/streams/privateLinkConnections/{connectionId}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async deleteVpcPeeringConnection(options, context) {
+        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}/streams/vpcPeeringConnections/{id}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async acceptVpcPeeringConnection(options, context) {
+        const { error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/streams/vpcPeeringConnections/{id}:accept", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async rejectVpcPeeringConnection(options, context) {
+        const { error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/streams/vpcPeeringConnections/{id}:reject", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async deleteStreamWorkspace(options, context) {
+        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}/streams/{tenantName}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    async getStreamWorkspace(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/streams/{tenantName}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async updateStreamWorkspace(options, context) {
+        const { data, error, response } = await this.client.PATCH("/api/atlas/v2/groups/{groupId}/streams/{tenantName}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async downloadAuditLogs(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/streams/{tenantName}/auditLogs", this.applyRequestContext({ ...options, headers: { Accept: "application/vnd.atlas.2023-02-01+gzip", ...options?.headers } }, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async listStreamConnections(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/streams/{tenantName}/connections", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async createStreamConnection(options, context) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/streams/{tenantName}/connections", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async deleteStreamConnection(options, context) {
+        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}/streams/{tenantName}/connections/{connectionName}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    async getStreamConnection(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/streams/{tenantName}/connections/{connectionName}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async updateStreamConnection(options, context) {
+        const { data, error, response } = await this.client.PATCH("/api/atlas/v2/groups/{groupId}/streams/{tenantName}/connections/{connectionName}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async createStreamProcessor(options, context) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/streams/{tenantName}/processor", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async deleteStreamProcessor(options, context) {
+        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}/streams/{tenantName}/processor/{processorName}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    async getStreamProcessor(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/streams/{tenantName}/processor/{processorName}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async updateStreamProcessor(options, context) {
+        const { data, error, response } = await this.client.PATCH("/api/atlas/v2/groups/{groupId}/streams/{tenantName}/processor/{processorName}", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async startStreamProcessor(options, context) {
+        const { error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/streams/{tenantName}/processor/{processorName}:start", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async startStreamProcessorWith(options, context) {
+        const { error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/streams/{tenantName}/processor/{processorName}:startWith", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async stopStreamProcessor(options, context) {
+        const { error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/streams/{tenantName}/processor/{processorName}:stop", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    async getStreamProcessors(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/streams/{tenantName}/processors", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async downloadOperationalLogs(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/streams/{tenantName}:downloadOperationalLogs", this.applyRequestContext({ ...options, headers: { Accept: "application/vnd.atlas.2025-03-12+gzip", ...options?.headers } }, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async withStreamSampleConnections(options, context) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/streams:withSampleConnections", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async listOrgs(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/orgs", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    async getOrgGroups(options, context) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/orgs/{orgId}/groups", this.applyRequestContext(options, context));
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+}
+//# sourceMappingURL=apiClient.js.map