@himanshusinghs/mongodb-mcp-server 0.3.0

package/dist/esm/common/atlas/apiClient.d.ts

@@ -0,0 +1,235 @@
+import type { FetchOptions } from "openapi-fetch";
+import type { operations } from "./openapi.js";
+import type { CommonProperties, TelemetryEvent } from "../../telemetry/types.js";
+import type { LoggerBase } from "../logger.js";
+export interface ApiClientCredentials {
+    clientId: string;
+    clientSecret: string;
+}
+export interface ApiClientOptions {
+    credentials?: ApiClientCredentials;
+    baseUrl: string;
+    userAgent?: string;
+}
+export interface AccessToken {
+    access_token: string;
+    expires_at?: number;
+}
+export declare class ApiClient {
+    readonly logger: LoggerBase;
+    private readonly options;
+    private static customFetch;
+    private client;
+    private oauth2Client?;
+    private oauth2Issuer?;
+    private accessToken?;
+    hasCredentials(): boolean;
+    private isAccessTokenValid;
+    private getAccessToken;
+    private authMiddleware;
+    constructor(options: ApiClientOptions, logger: LoggerBase);
+    private getOauthClientAuth;
+    private getNewAccessToken;
+    validateAccessToken(): Promise<void>;
+    close(): Promise<void>;
+    getIpInfo(): Promise<{
+        currentIpv4Address: string;
+    }>;
+    sendEvents(events: TelemetryEvent<CommonProperties>[]): Promise<void>;
+    private sendAuthEvents;
+    private sendUnauthEvents;
+    listClustersForAllProjects(options?: FetchOptions<operations["listClustersForAllProjects"]>): Promise<{
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        readonly results?: import("./openapi.js").components["schemas"]["OrgGroup"][];
+        readonly totalCount?: number;
+    }>;
+    listProjects(options?: FetchOptions<operations["listProjects"]>): Promise<{
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        readonly results?: import("./openapi.js").components["schemas"]["Group"][];
+        readonly totalCount?: number;
+    }>;
+    createProject(options: FetchOptions<operations["createProject"]>): Promise<{
+        readonly clusterCount: number;
+        readonly created: string;
+        readonly id?: string;
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        name: string;
+        orgId: string;
+        regionUsageRestrictions: "COMMERCIAL_FEDRAMP_REGIONS_ONLY" | "GOV_REGIONS_ONLY";
+        tags?: import("./openapi.js").components["schemas"]["ResourceTag"][];
+        withDefaultAlertsSettings: boolean;
+    }>;
+    deleteProject(options: FetchOptions<operations["deleteProject"]>): Promise<void>;
+    getProject(options: FetchOptions<operations["getProject"]>): Promise<{
+        readonly clusterCount: number;
+        readonly created: string;
+        readonly id?: string;
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        name: string;
+        orgId: string;
+        regionUsageRestrictions: "COMMERCIAL_FEDRAMP_REGIONS_ONLY" | "GOV_REGIONS_ONLY";
+        tags?: import("./openapi.js").components["schemas"]["ResourceTag"][];
+        withDefaultAlertsSettings: boolean;
+    }>;
+    listProjectIpAccessLists(options: FetchOptions<operations["listProjectIpAccessLists"]>): Promise<{
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        readonly results?: import("./openapi.js").components["schemas"]["NetworkPermissionEntry"][];
+        readonly totalCount?: number;
+    }>;
+    createProjectIpAccessList(options: FetchOptions<operations["createProjectIpAccessList"]>): Promise<{
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        readonly results?: import("./openapi.js").components["schemas"]["NetworkPermissionEntry"][];
+        readonly totalCount?: number;
+    }>;
+    deleteProjectIpAccessList(options: FetchOptions<operations["deleteProjectIpAccessList"]>): Promise<void>;
+    listAlerts(options: FetchOptions<operations["listAlerts"]>): Promise<{
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        readonly results?: import("./openapi.js").components["schemas"]["AlertViewForNdsGroup"][];
+        readonly totalCount?: number;
+    }>;
+    listClusters(options: FetchOptions<operations["listClusters"]>): Promise<{
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        readonly results?: import("./openapi.js").components["schemas"]["ClusterDescription20240805"][];
+        readonly totalCount?: number;
+    }>;
+    createCluster(options: FetchOptions<operations["createCluster"]>): Promise<{
+        acceptDataRisksAndForceReplicaSetReconfig?: string;
+        advancedConfiguration?: import("./openapi.js").components["schemas"]["ApiAtlasClusterAdvancedConfigurationView"];
+        backupEnabled: boolean;
+        biConnector?: import("./openapi.js").components["schemas"]["BiConnector"];
+        clusterType?: "REPLICASET" | "SHARDED" | "GEOSHARDED";
+        configServerManagementMode: "ATLAS_MANAGED" | "FIXED_TO_DEDICATED";
+        readonly configServerType?: "DEDICATED" | "EMBEDDED";
+        connectionStrings?: import("./openapi.js").components["schemas"]["ClusterConnectionStrings"];
+        readonly createDate?: string;
+        diskWarmingMode: "FULLY_WARMED" | "VISIBLE_EARLIER";
+        encryptionAtRestProvider?: "NONE" | "AWS" | "AZURE" | "GCP";
+        readonly featureCompatibilityVersion?: string;
+        readonly featureCompatibilityVersionExpirationDate?: string;
+        globalClusterSelfManagedSharding?: boolean;
+        readonly groupId?: string;
+        readonly id?: string;
+        labels?: import("./openapi.js").components["schemas"]["ComponentLabel"][];
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        mongoDBEmployeeAccessGrant?: import("./openapi.js").components["schemas"]["EmployeeAccessGrantView"];
+        mongoDBMajorVersion?: string;
+        readonly mongoDBVersion?: string;
+        name?: string;
+        paused?: boolean;
+        pitEnabled?: boolean;
+        redactClientLogData?: boolean;
+        replicaSetScalingStrategy: "SEQUENTIAL" | "WORKLOAD_TYPE" | "NODE_TYPE";
+        replicationSpecs?: import("./openapi.js").components["schemas"]["ReplicationSpec20240805"][];
+        rootCertType: "ISRGROOTX1";
+        readonly stateName?: "IDLE" | "CREATING" | "UPDATING" | "DELETING" | "REPAIRING";
+        tags?: import("./openapi.js").components["schemas"]["ResourceTag"][];
+        terminationProtectionEnabled: boolean;
+        versionReleaseSystem: "LTS" | "CONTINUOUS";
+    }>;
+    deleteCluster(options: FetchOptions<operations["deleteCluster"]>): Promise<void>;
+    getCluster(options: FetchOptions<operations["getCluster"]>): Promise<{
+        acceptDataRisksAndForceReplicaSetReconfig?: string;
+        advancedConfiguration?: import("./openapi.js").components["schemas"]["ApiAtlasClusterAdvancedConfigurationView"];
+        backupEnabled: boolean;
+        biConnector?: import("./openapi.js").components["schemas"]["BiConnector"];
+        clusterType?: "REPLICASET" | "SHARDED" | "GEOSHARDED";
+        configServerManagementMode: "ATLAS_MANAGED" | "FIXED_TO_DEDICATED";
+        readonly configServerType?: "DEDICATED" | "EMBEDDED";
+        connectionStrings?: import("./openapi.js").components["schemas"]["ClusterConnectionStrings"];
+        readonly createDate?: string;
+        diskWarmingMode: "FULLY_WARMED" | "VISIBLE_EARLIER";
+        encryptionAtRestProvider?: "NONE" | "AWS" | "AZURE" | "GCP";
+        readonly featureCompatibilityVersion?: string;
+        readonly featureCompatibilityVersionExpirationDate?: string;
+        globalClusterSelfManagedSharding?: boolean;
+        readonly groupId?: string;
+        readonly id?: string;
+        labels?: import("./openapi.js").components["schemas"]["ComponentLabel"][];
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        mongoDBEmployeeAccessGrant?: import("./openapi.js").components["schemas"]["EmployeeAccessGrantView"];
+        mongoDBMajorVersion?: string;
+        readonly mongoDBVersion?: string;
+        name?: string;
+        paused?: boolean;
+        pitEnabled?: boolean;
+        redactClientLogData?: boolean;
+        replicaSetScalingStrategy: "SEQUENTIAL" | "WORKLOAD_TYPE" | "NODE_TYPE";
+        replicationSpecs?: import("./openapi.js").components["schemas"]["ReplicationSpec20240805"][];
+        rootCertType: "ISRGROOTX1";
+        readonly stateName?: "IDLE" | "CREATING" | "UPDATING" | "DELETING" | "REPAIRING";
+        tags?: import("./openapi.js").components["schemas"]["ResourceTag"][];
+        terminationProtectionEnabled: boolean;
+        versionReleaseSystem: "LTS" | "CONTINUOUS";
+    }>;
+    listDatabaseUsers(options: FetchOptions<operations["listDatabaseUsers"]>): Promise<{
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        readonly results?: import("./openapi.js").components["schemas"]["CloudDatabaseUser"][];
+        readonly totalCount?: number;
+    }>;
+    createDatabaseUser(options: FetchOptions<operations["createDatabaseUser"]>): Promise<{
+        awsIAMType: "NONE" | "USER" | "ROLE";
+        databaseName: "admin" | "$external";
+        deleteAfterDate?: string;
+        description?: string;
+        groupId: string;
+        labels?: import("./openapi.js").components["schemas"]["ComponentLabel"][];
+        ldapAuthType: "NONE" | "GROUP" | "USER";
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        oidcAuthType: "NONE" | "IDP_GROUP" | "USER";
+        password?: string;
+        roles?: import("./openapi.js").components["schemas"]["DatabaseUserRole"][];
+        scopes?: import("./openapi.js").components["schemas"]["UserScope"][];
+        username: string;
+        x509Type: "NONE" | "CUSTOMER" | "MANAGED";
+    }>;
+    deleteDatabaseUser(options: FetchOptions<operations["deleteDatabaseUser"]>): Promise<void>;
+    listFlexClusters(options: FetchOptions<operations["listFlexClusters"]>): Promise<{
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        readonly results?: import("./openapi.js").components["schemas"]["FlexClusterDescription20241113"][];
+        readonly totalCount?: number;
+    }>;
+    createFlexCluster(options: FetchOptions<operations["createFlexCluster"]>): Promise<{
+        backupSettings?: import("./openapi.js").components["schemas"]["FlexBackupSettings20241113"];
+        readonly clusterType: "REPLICASET";
+        connectionStrings?: import("./openapi.js").components["schemas"]["FlexConnectionStrings20241113"];
+        readonly createDate?: string;
+        readonly groupId?: string;
+        readonly id?: string;
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        readonly mongoDBVersion?: string;
+        readonly name?: string;
+        providerSettings: import("./openapi.js").components["schemas"]["FlexProviderSettings20241113"];
+        readonly stateName?: "IDLE" | "CREATING" | "UPDATING" | "DELETING" | "REPAIRING";
+        tags?: import("./openapi.js").components["schemas"]["ResourceTag"][];
+        terminationProtectionEnabled: boolean;
+        readonly versionReleaseSystem: "LTS";
+    }>;
+    deleteFlexCluster(options: FetchOptions<operations["deleteFlexCluster"]>): Promise<void>;
+    getFlexCluster(options: FetchOptions<operations["getFlexCluster"]>): Promise<{
+        backupSettings?: import("./openapi.js").components["schemas"]["FlexBackupSettings20241113"];
+        readonly clusterType: "REPLICASET";
+        connectionStrings?: import("./openapi.js").components["schemas"]["FlexConnectionStrings20241113"];
+        readonly createDate?: string;
+        readonly groupId?: string;
+        readonly id?: string;
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        readonly mongoDBVersion?: string;
+        readonly name?: string;
+        providerSettings: import("./openapi.js").components["schemas"]["FlexProviderSettings20241113"];
+        readonly stateName?: "IDLE" | "CREATING" | "UPDATING" | "DELETING" | "REPAIRING";
+        tags?: import("./openapi.js").components["schemas"]["ResourceTag"][];
+        terminationProtectionEnabled: boolean;
+        readonly versionReleaseSystem: "LTS";
+    }>;
+    listOrganizations(options?: FetchOptions<operations["listOrganizations"]>): Promise<{
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        readonly results?: import("./openapi.js").components["schemas"]["AtlasOrganization"][];
+        readonly totalCount?: number;
+    }>;
+    listOrganizationProjects(options: FetchOptions<operations["listOrganizationProjects"]>): Promise<{
+        readonly links?: import("./openapi.js").components["schemas"]["Link"][];
+        readonly results?: import("./openapi.js").components["schemas"]["Group"][];
+        readonly totalCount?: number;
+    }>;
+}
+//# sourceMappingURL=apiClient.d.ts.map

package/dist/esm/common/atlas/apiClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiClient.d.ts","sourceRoot":"","sources":["../../../../src/common/atlas/apiClient.ts"],"names":[],"mappings":"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"}

package/dist/esm/common/atlas/apiClient.js

@@ -0,0 +1,399 @@
+import createClient from "openapi-fetch";
+import { ApiClientError } from "./apiClientError.js";
+import { packageInfo } from "../packageInfo.js";
+import { LogId } from "../logger.js";
+import { createFetch } from "@mongodb-js/devtools-proxy-support";
+import * as oauth from "oauth4webapi";
+import { Request as NodeFetchRequest } from "node-fetch";
+const ATLAS_API_VERSION = "2025-03-12";
+export class ApiClient {
+    hasCredentials() {
+        return !!this.oauth2Client && !!this.oauth2Issuer;
+    }
+    isAccessTokenValid() {
+        return !!(this.accessToken &&
+            this.accessToken.expires_at !== undefined &&
+            this.accessToken.expires_at > Date.now());
+    }
+    constructor(options, logger) {
+        this.logger = logger;
+        this.getAccessToken = async () => {
+            if (!this.hasCredentials()) {
+                return undefined;
+            }
+            if (!this.isAccessTokenValid()) {
+                this.accessToken = await this.getNewAccessToken();
+            }
+            return this.accessToken?.access_token;
+        };
+        this.authMiddleware = {
+            onRequest: async ({ request, schemaPath }) => {
+                if (schemaPath.startsWith("/api/private/unauth") || schemaPath.startsWith("/api/oauth")) {
+                    return undefined;
+                }
+                try {
+                    const accessToken = await this.getAccessToken();
+                    if (accessToken) {
+                        request.headers.set("Authorization", `Bearer ${accessToken}`);
+                    }
+                    return request;
+                }
+                catch {
+                    // ignore not availble tokens, API will return 401
+                    return undefined;
+                }
+            },
+        };
+        this.options = {
+            ...options,
+            userAgent: options.userAgent ||
+                `AtlasMCP/${packageInfo.version} (${process.platform}; ${process.arch}; ${process.env.HOSTNAME || "unknown"})`,
+        };
+        this.client = createClient({
+            baseUrl: this.options.baseUrl,
+            headers: {
+                "User-Agent": this.options.userAgent,
+                Accept: `application/vnd.atlas.${ATLAS_API_VERSION}+json`,
+            },
+            fetch: ApiClient.customFetch,
+            // NodeFetchRequest has more overloadings than the native Request
+            // so it complains here. However, the interfaces are actually compatible
+            // so it's not a real problem, just a type checking problem.
+            Request: NodeFetchRequest,
+        });
+        if (this.options.credentials?.clientId && this.options.credentials?.clientSecret) {
+            this.oauth2Issuer = {
+                issuer: this.options.baseUrl,
+                token_endpoint: new URL("/api/oauth/token", this.options.baseUrl).toString(),
+                revocation_endpoint: new URL("/api/oauth/revoke", this.options.baseUrl).toString(),
+                token_endpoint_auth_methods_supported: ["client_secret_basic"],
+                grant_types_supported: ["client_credentials"],
+            };
+            this.oauth2Client = {
+                client_id: this.options.credentials.clientId,
+                client_secret: this.options.credentials.clientSecret,
+            };
+            this.client.use(this.authMiddleware);
+        }
+    }
+    getOauthClientAuth() {
+        if (this.options.credentials?.clientId && this.options.credentials.clientSecret) {
+            const clientSecret = this.options.credentials.clientSecret;
+            const clientId = this.options.credentials.clientId;
+            // We are using our own ClientAuth because ClientSecretBasic URL encodes wrongly
+            // the username and password (for example, encodes `_` to %5F, which is wrong).
+            return {
+                client: { client_id: clientId },
+                clientAuth: (_as, client, _body, headers) => {
+                    const credentials = Buffer.from(`${clientId}:${clientSecret}`).toString("base64");
+                    headers.set("Authorization", `Basic ${credentials}`);
+                },
+            };
+        }
+        return { client: undefined, clientAuth: undefined };
+    }
+    async getNewAccessToken() {
+        if (!this.hasCredentials() || !this.oauth2Issuer) {
+            return undefined;
+        }
+        const { client, clientAuth } = this.getOauthClientAuth();
+        if (client && clientAuth) {
+            try {
+                const response = await oauth.clientCredentialsGrantRequest(this.oauth2Issuer, client, clientAuth, new URLSearchParams(), {
+                    [oauth.customFetch]: ApiClient.customFetch,
+                    headers: {
+                        "User-Agent": this.options.userAgent,
+                    },
+                });
+                const result = await oauth.processClientCredentialsResponse(this.oauth2Issuer, client, response);
+                this.accessToken = {
+                    access_token: result.access_token,
+                    expires_at: Date.now() + (result.expires_in ?? 0) * 1000,
+                };
+            }
+            catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                this.logger.error({
+                    id: LogId.atlasConnectFailure,
+                    context: "apiClient",
+                    message: `Failed to request access token: ${err.message}`,
+                });
+            }
+            return this.accessToken;
+        }
+        return undefined;
+    }
+    async validateAccessToken() {
+        await this.getAccessToken();
+    }
+    async close() {
+        const { client, clientAuth } = this.getOauthClientAuth();
+        try {
+            if (this.oauth2Issuer && this.accessToken && client && clientAuth) {
+                await oauth.revocationRequest(this.oauth2Issuer, client, clientAuth, this.accessToken.access_token);
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error({
+                id: LogId.atlasApiRevokeFailure,
+                context: "apiClient",
+                message: `Failed to revoke access token: ${err.message}`,
+            });
+        }
+        this.accessToken = undefined;
+    }
+    async getIpInfo() {
+        const accessToken = await this.getAccessToken();
+        const endpoint = "api/private/ipinfo";
+        const url = new URL(endpoint, this.options.baseUrl);
+        const response = await fetch(url, {
+            method: "GET",
+            headers: {
+                Accept: "application/json",
+                Authorization: `Bearer ${accessToken}`,
+                "User-Agent": this.options.userAgent,
+            },
+        });
+        if (!response.ok) {
+            throw await ApiClientError.fromResponse(response);
+        }
+        return (await response.json());
+    }
+    async sendEvents(events) {
+        if (!this.options.credentials) {
+            await this.sendUnauthEvents(events);
+            return;
+        }
+        try {
+            await this.sendAuthEvents(events);
+        }
+        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);
+        }
+    }
+    async sendAuthEvents(events) {
+        const accessToken = await this.getAccessToken();
+        if (!accessToken) {
+            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: {
+                Accept: "application/json",
+                "Content-Type": "application/json",
+                "User-Agent": this.options.userAgent,
+                Authorization: `Bearer ${accessToken}`,
+            },
+            body: JSON.stringify(events),
+        });
+        if (!response.ok) {
+            throw await ApiClientError.fromResponse(response);
+        }
+    }
+    async sendUnauthEvents(events) {
+        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),
+        });
+        if (!response.ok) {
+            throw await ApiClientError.fromResponse(response);
+        }
+    }
+    // DO NOT EDIT. This is auto-generated code.
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async listClustersForAllProjects(options) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/clusters", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async listProjects(options) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async createProject(options) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async deleteProject(options) {
+        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async getProject(options) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async listProjectIpAccessLists(options) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/accessList", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async createProjectIpAccessList(options) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/accessList", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async deleteProjectIpAccessList(options) {
+        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}/accessList/{entryValue}", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async listAlerts(options) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/alerts", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async listClusters(options) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/clusters", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async createCluster(options) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/clusters", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async deleteCluster(options) {
+        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}/clusters/{clusterName}", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async getCluster(options) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/clusters/{clusterName}", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async listDatabaseUsers(options) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/databaseUsers", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async createDatabaseUser(options) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/databaseUsers", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async deleteDatabaseUser(options) {
+        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}/databaseUsers/{databaseName}/{username}", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async listFlexClusters(options) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/flexClusters", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async createFlexCluster(options) {
+        const { data, error, response } = await this.client.POST("/api/atlas/v2/groups/{groupId}/flexClusters", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async deleteFlexCluster(options) {
+        const { error, response } = await this.client.DELETE("/api/atlas/v2/groups/{groupId}/flexClusters/{name}", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async getFlexCluster(options) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/groups/{groupId}/flexClusters/{name}", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async listOrganizations(options) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/orgs", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    async listOrganizationProjects(options) {
+        const { data, error, response } = await this.client.GET("/api/atlas/v2/orgs/{orgId}/groups", options);
+        if (error) {
+            throw ApiClientError.fromError(response, error);
+        }
+        return data;
+    }
+}
+// createFetch assumes that the first parameter of fetch is always a string
+// with the URL. However, fetch can also receive a Request object. While
+// the typechecking complains, createFetch does passthrough the parameters
+// so it works fine.
+ApiClient.customFetch = createFetch({
+    useEnvironmentVariableProxies: true,
+});
+//# sourceMappingURL=apiClient.js.map