@atlasauth/backend 0.5.0 → 0.6.0

package/dist/client/index.d.ts

@@ -1,4 +1,5 @@
-import { type AtlasClientConfig } from './request';
+import { type AtlasClientConfig, type AtlasRequestSettings } from './request';
+import type { RequestFn } from './request';
 /**
  * The typed management client for the Atlas Backend API — the secret-key
  * surface, the peer of `@clerk/backend`'s `createClerkClient`.
@@ -8,7 +9,8 @@ import { type AtlasClientConfig } from './request';
  * mapping and the wire types live, so this file stays a table of contents you
  * can read top to bottom to see the whole surface.
  */
-export declare function createAtlasClient(config: AtlasClientConfig): {
+export declare function createAtlasClient(config: AtlasClientConfig): AtlasClient;
+declare function buildNamespaces(request: RequestFn): {
     users: {
         list(params?: import("./users").ListUsersParams): Promise<import("./types").CursorPage<import("./users").User>>;
         get(id: string): Promise<import("./users").User>;
@@ -85,6 +87,75 @@ export declare function createAtlasClient(config: AtlasClientConfig): {
             deleted: true;
             tokens_revoked: number;
         }>;
+        byEmails(body: import("./users").UsersByEmailsBody): Promise<import("./types").ListPage<import("./users").UserEmailMatch>>;
+        resolved(id: string): Promise<import("./users").ResolvedUser>;
+        state(id: string): Promise<import("./users").UserState>;
+        signInHistory(id: string, params?: import("./types").CursorParams): Promise<import("./types").CursorPage<import("./users").SignInEvent>>;
+        listOrganizationMemberships(id: string, params?: import("./types").CursorParams): Promise<import("./types").CursorPage<import("./users").UserOrganizationMembership>>;
+        setPassword(id: string, body: import("./users").SetUserPasswordBody): Promise<import("./users").User>;
+        deleteProfileImage(id: string): Promise<import("./users").User>;
+        deletePasskey(id: string, passkeyId: string): Promise<{
+            object: "passkey";
+            id: string;
+            deleted: true;
+        }>;
+        importIdentity(id: string, body: import("./users").ImportIdentityBody): Promise<import("./users").Identity>;
+        removeIdentityByProvider(id: string, provider: string): Promise<{
+            object: string;
+            id: string;
+            provider: string;
+            removed: boolean;
+        }>;
+        acknowledgeErasure(id: string, body: import("./users").UserErasureAckBody, idempotencyKey?: string): Promise<import("./users").UserErasureAck>;
+        erasureExport(id: string): Promise<import("./users").UserErasureExport>;
+        deletion: {
+            schedule(id: string, body?: {
+                grace_seconds?: number;
+            }, idempotencyKey?: string): Promise<import("./users").User>;
+            cancel(id: string, idempotencyKey?: string): Promise<import("./users").User>;
+            finalize(id: string, idempotencyKey?: string): Promise<{
+                object: "user";
+                id: string;
+                deleted: true;
+            }>;
+        };
+        directives: {
+            impose(id: string, body: import("./users").ImposeUserDirectiveBody, idempotencyKey?: string): Promise<import("./users").UserDirective>;
+            lift(id: string): Promise<{
+                object: "directive";
+                user_id: string;
+                lifted: true;
+            }>;
+        };
+        consents: {
+            list(id: string): Promise<{
+                object: string;
+                data: import("./users").UserConsent[];
+            }>;
+            record(id: string, body: import("./users").RecordUserConsentBody, idempotencyKey?: string): Promise<import("./users").UserConsent>;
+        };
+        approvalRequests: {
+            create(id: string, body: import("./users").CreateUserApprovalRequestBody): Promise<import("./users").UserApprovalRequestCreated>;
+            get(id: string, approvalId: string): Promise<import("./users").UserApprovalRequest>;
+        };
+        notificationPreferences: {
+            get(id: string): Promise<import("./users").UserNotificationPreferences>;
+            update(id: string, body: import("./users").UpdateUserNotificationPreferencesBody): Promise<import("./users").UserNotificationPreferences>;
+        };
+        phoneNumbers: {
+            add(id: string, body: {
+                phone_number: string;
+            }): Promise<import("./users").UserPhoneNumber>;
+            verify(id: string, phoneId: string): Promise<import("./users").UserPhoneNumber>;
+            delete(id: string, phoneId: string): Promise<{
+                object: "phone_number";
+                id: string;
+                deleted: true;
+            }>;
+        };
+        progression: {
+            addEvent(id: string, body: import("./users").UserProgressionEventBody): Promise<import("./users").UserProgressionEvent>;
+        };
     };
     sessions: {
         create(params: import("./sessions").CreateSessionParams): Promise<import("./sessions").MintedSession>;
@@ -95,6 +166,7 @@ export declare function createAtlasClient(config: AtlasClientConfig): {
             id: string;
             status: "revoked";
         }>;
+        getToken(id: string, template: string): Promise<import("./sessions").SessionTemplateToken>;
     };
     organizations: {
         list(params?: import("./types").CursorParams): Promise<import("./types").CursorPage<import("./organizations").Organization>>;
@@ -173,6 +245,49 @@ export declare function createAtlasClient(config: AtlasClientConfig): {
                 deleted: true;
             }>;
         };
+        settings: {
+            get(orgId: string): Promise<import("./organizations").OrganizationSettings>;
+            replace(orgId: string, values: Record<string, unknown>, idempotencyKey?: string): Promise<import("./organizations").OrganizationSettings>;
+            update(orgId: string, values: Record<string, unknown>, idempotencyKey?: string): Promise<import("./organizations").OrganizationSettings>;
+        };
+        auditStreams: {
+            list(orgId: string): Promise<import("./types").ListPage<import("./organizations").OrganizationAuditStream>>;
+            create(orgId: string, body: import("./organizations").CreateOrganizationAuditStreamBody, idempotencyKey?: string): Promise<import("./organizations").OrganizationAuditStream>;
+            delete(orgId: string, streamId: string): Promise<{
+                object: "org_audit_stream";
+                id: string;
+                deleted: true;
+            }>;
+        };
+        branding: {
+            get(orgId: string): Promise<import("./organizations").OrganizationBranding>;
+            update(orgId: string, body: import("./organizations").UpdateOrganizationBrandingBody): Promise<import("./organizations").OrganizationBranding>;
+        };
+        endUsers: {
+            list(orgId: string, params?: import("./organizations").ListOrganizationEndUsersParams): Promise<import("./types").CursorPage<import("./organizations").OrganizationEndUser> & {
+                object: "list";
+            }>;
+            add(orgId: string, body: import("./organizations").AddOrganizationEndUserBody, idempotencyKey?: string): Promise<import("./organizations").OrganizationEndUser>;
+            update(orgId: string, userId: string, body: {
+                status: import("./organizations").OrganizationEndUserStatus;
+            }): Promise<import("./organizations").OrganizationEndUser>;
+            remove(orgId: string, userId: string): Promise<{
+                object: "organization_end_user";
+                id: string;
+                deleted: true;
+            }>;
+        };
+        readerDomain: {
+            list(orgId: string): Promise<import("./types").ListPage<import("./organizations").OrganizationReaderDomain>>;
+            create(orgId: string, body: {
+                host: string;
+            }, idempotencyKey?: string): Promise<import("./organizations").OrganizationReaderDomainCreated>;
+            delete(orgId: string): Promise<{
+                object: "custom_domain";
+                id: string;
+                deleted: true;
+            }>;
+        };
         groupRoles: {
             grant(orgId: string, groupId: string, roleId: string): Promise<{
                 object: "group_role_grant";
@@ -215,6 +330,9 @@ export declare function createAtlasClient(config: AtlasClientConfig): {
         }>;
     };
     oauthClients: {
+        import(body: {
+            clients: import("./oauth-clients").ImportOAuthClientEntry[];
+        }, idempotencyKey?: string): Promise<import("./types").ListPage<import("./oauth-clients").ImportedOAuthClient>>;
         list(): Promise<import("./types").ListPage<import("./oauth-clients").OAuthClient>>;
         get(id: string): Promise<import("./oauth-clients").OAuthClient>;
         create(body: import("./oauth-clients").CreateOAuthClientBody, idempotencyKey?: string): Promise<import("./oauth-clients").OAuthClientWithSecret>;
@@ -290,6 +408,15 @@ export declare function createAtlasClient(config: AtlasClientConfig): {
         }>;
     };
     waitlist: {
+        create(body: {
+            email_address: string;
+        }, idempotencyKey?: string): Promise<import("./waitlist").WaitlistEntry>;
+        bulkCreate(emailAddresses: string[], idempotencyKey?: string): Promise<import("./waitlist").BulkWaitlistResult>;
+        delete(id: string): Promise<{
+            object: "waitlist_entry";
+            id: string;
+            deleted: true;
+        }>;
         list(params?: import("./waitlist").ListWaitlistParams): Promise<import("./waitlist").ListWaitlistResponse>;
         decide(id: string, body: {
             status: "approved" | "denied";
@@ -335,16 +462,19 @@ export declare function createAtlasClient(config: AtlasClientConfig): {
         }>;
     };
     invitations: {
+        bulkCreate(invitations: import("./invitations").CreateInvitationBody[], idempotencyKey?: string): Promise<import("./invitations").BulkInvitationsResult>;
         list(params?: import("./types").CursorParams): Promise<import("./types").CursorPage<import("./invitations").Invitation>>;
         create(body: import("./invitations").CreateInvitationBody, idempotencyKey?: string): Promise<import("./invitations").Invitation>;
         revoke(id: string): Promise<import("./invitations").Invitation>;
     };
     webhooks: {
         endpoints: {
-            list(): Promise<{
-                data: import("./webhooks").WebhookEndpoint[];
-                has_more: false;
-            }>;
+            list(): Promise<import("./webhooks").WebhookEndpointList>;
+            update(id: string, body: import("./webhooks").UpdateWebhookEndpointBody): Promise<import("./webhooks").WebhookEndpoint>;
+            revealSecret(id: string): Promise<import("./webhooks").WebhookSigningSecret>;
+            rotateSecret(id: string): Promise<import("./webhooks").WebhookSigningSecret>;
+            test(id: string): Promise<import("./webhooks").WebhookDeliveryQueued>;
+            redeliver(id: string, deliveryId: string): Promise<import("./webhooks").WebhookDeliveryQueued>;
             create(body: import("./webhooks").CreateWebhookEndpointBody, idempotencyKey?: string): Promise<import("./webhooks").WebhookEndpointWithSecret>;
             delete(id: string): Promise<{
                 object: "webhook_endpoint";
@@ -352,13 +482,20 @@ export declare function createAtlasClient(config: AtlasClientConfig): {
                 deleted: true;
             }>;
         };
-        deliveries(id: string): Promise<{
+        deliveries(id: string, params?: import("./webhooks").ListWebhookDeliveriesParams): Promise<{
             data: import("./webhooks").WebhookDelivery[];
-            has_more: false;
+            has_more: boolean;
+            next_cursor?: string | null;
         }>;
+        redeliver(endpointId: string, deliveryId: string): Promise<import("./webhooks").WebhookDeliveryQueued>;
     };
     signInTokens: {
         create(body: import("./sign-in-tokens").CreateSignInTokenBody, idempotencyKey?: string): Promise<import("./sign-in-tokens").SignInToken>;
+        revoke(id: string): Promise<{
+            object: "sign_in_token";
+            id: string;
+            revoked: true;
+        }>;
     };
     auditLogs: {
         list(params?: import("./audit-logs").ListAuditLogsParams): Promise<import("./types").CursorPage<import("./audit-logs").AuditLog>>;
@@ -419,13 +556,9 @@ export declare function createAtlasClient(config: AtlasClientConfig): {
         verifyM2mToken(token: string): Promise<import("./machines").M2mTokenVerification>;
     };
     oauthProviders: {
-        list(): Promise<import("./types").ListPage<import("./oauth-providers").OAuthProvider>>;
+        list(params?: import("./oauth-providers").ListOAuthProvidersParams): Promise<import("./types").ListPage<import("./oauth-providers").OAuthProvider>>;
         get(provider: string): Promise<import("./oauth-providers").OAuthProvider>;
-        upsert(provider: string, body: import("./oauth-providers").UpsertOAuthProviderBody, idempotencyKey?: string): Promise<{
-            object: "oauth_provider";
-            provider: string;
-            configured: true;
-        }>;
+        upsert(provider: string, body: import("./oauth-providers").UpsertOAuthProviderBody, idempotencyKey?: string): Promise<import("./oauth-providers").OAuthProviderUpsertResult>;
         delete(provider: string): Promise<{
             object: "oauth_provider";
             provider: string;
@@ -678,6 +811,9 @@ export declare function createAtlasClient(config: AtlasClientConfig): {
             deleted: true;
         }>;
         listSubscriptions(params?: import("./billing-plans").ListSubscriptionsParams): Promise<import("./types").ListPage<import("./billing-plans").BillingSubscription>>;
+        importSubscription(body: import("./billing-plans").ImportBillingSubscriptionBody, idempotencyKey?: string): Promise<import("./billing-plans").BillingSubscription>;
+        reportUsage(body: import("./billing-plans").ReportBillingUsageBody): Promise<import("./billing-plans").BillingUsageReport>;
+        syncSeats(subjectType: "user" | "org", subjectId: string): Promise<import("./billing-plans").BillingSeatSync>;
     };
     messaging: {
         get(): Promise<import("./messaging").MessagingProviders>;
@@ -706,6 +842,8 @@ export declare function createAtlasClient(config: AtlasClientConfig): {
         getJobErrors(id: string): Promise<import("./types").ListPage<import("./import-export").JobError>>;
     };
     dataSubjectRequests: {
+        create(body: import("./data-subject-requests").CreateDataSubjectRequestBody, idempotencyKey?: string): Promise<import("./data-subject-requests").DataSubjectRequest>;
+        cancel(id: string): Promise<import("./data-subject-requests").DataSubjectRequest>;
         list(params?: import("./data-subject-requests").ListDataSubjectRequestsParams): Promise<import("./types").CursorPage<import("./data-subject-requests").DataSubjectRequest>>;
         get(id: string): Promise<import("./data-subject-requests").DataSubjectRequest>;
         fulfill(id: string, idempotencyKey?: string): Promise<import("./data-subject-requests").DataSubjectRequest>;
@@ -738,6 +876,12 @@ export declare function createAtlasClient(config: AtlasClientConfig): {
     instance: {
         get(): Promise<import("./instance").Instance>;
         update(body: import("./instance").UpdateInstanceBody): Promise<import("./instance").InstanceUpdateResult>;
+        preflight(): Promise<import("./instance").PreflightReport>;
+        cookieConsent: {
+            get(): Promise<import("./instance").CookieConsent>;
+            set(body: import("./instance").SetCookieConsentBody): Promise<import("./instance").CookieConsent>;
+            delete(): Promise<import("./instance").CookieConsent>;
+        };
     };
     instanceSecurity: {
         get(): Promise<import("./instance-security").InstanceSecurity>;
@@ -783,11 +927,290 @@ export declare function createAtlasClient(config: AtlasClientConfig): {
     captcha: {
         verify(token: string, options?: import("./captcha").VerifyCaptchaOptions): Promise<import("./captcha").CaptchaVerification>;
     };
+    design: {
+        get(): Promise<import("./design").DesignSettings>;
+        replace(design: import("./design").AtlasDesign): Promise<import("./design").DesignSettings>;
+        update(design: import("./design").AtlasDesignPatch): Promise<import("./design").DesignSettings>;
+        preview(design: import("./design").AtlasDesign): Promise<import("./design").DesignPreview>;
+        organizations: {
+            get(organizationId: string): Promise<import("./design").DesignSettings>;
+            replace(organizationId: string, design: import("./design").AtlasDesign): Promise<import("./design").DesignSettings>;
+            update(organizationId: string, design: import("./design").AtlasDesignPatch): Promise<import("./design").DesignSettings>;
+        };
+        assets: {
+            upload(data: import("./design").DesignAssetData, options?: import("./design").UploadDesignAssetOptions): Promise<import("./design").DesignAsset>;
+            list(): Promise<import("./types").ListPage<import("./design").DesignAsset>>;
+            delete(assetId: string): Promise<import("./design").DeletedDesignAsset>;
+        };
+        catalog(): Promise<import("./design").DesignCatalog>;
+    };
+    entitlementOverrides: {
+        create(body: import("./entitlement-overrides").CreateEntitlementOverrideBody, idempotencyKey?: string): Promise<import("./entitlement-overrides").EntitlementOverride>;
+        list(params?: import("./entitlement-overrides").ListEntitlementOverridesParams): Promise<import("./types").ListPage<import("./entitlement-overrides").EntitlementOverride>>;
+        delete(id: string): Promise<{
+            object: "entitlement_override";
+            id: string;
+            deleted: true;
+        }>;
+    };
+    orgLdapConnections: {
+        list(params?: {
+            organization_id?: string;
+        }): Promise<import("./types").ListPage<import("./org-ldap-connections").OrgLdapConnection>>;
+        create(body: import("./org-ldap-connections").CreateOrgLdapConnectionBody, idempotencyKey?: string): Promise<import("./org-ldap-connections").OrgLdapConnection>;
+        get(id: string): Promise<import("./org-ldap-connections").OrgLdapConnection>;
+        update(id: string, body: import("./org-ldap-connections").UpdateOrgLdapConnectionBody, idempotencyKey?: string): Promise<import("./org-ldap-connections").OrgLdapConnection>;
+        delete(id: string): Promise<{
+            object: "org_ldap_connection";
+            id: string;
+            deleted: true;
+        }>;
+        test(id: string, body?: {
+            bind_password?: string;
+        }): Promise<import("./org-ldap-connections").OrgLdapConnectionTest>;
+    };
+    organizationSettingsSchema: {
+        get(): Promise<import("./organization-settings-schema").OrganizationSettingsSchema>;
+        create(schema: Record<string, unknown>, idempotencyKey?: string): Promise<import("./organization-settings-schema").OrganizationSettingsSchema>;
+        replace(schema: Record<string, unknown>, idempotencyKey?: string): Promise<import("./organization-settings-schema").OrganizationSettingsSchema>;
+    };
+    emailAddresses: {
+        verify(id: string): Promise<import("./email-addresses").EmailAddressRecord>;
+        setPrimary(id: string): Promise<import("./email-addresses").EmailAddressRecord>;
+    };
+    openfga: {
+        stores: {
+            list(): Promise<{
+                stores: import("./openfga").OpenFgaStore[];
+            }>;
+            create(body: {
+                name: string;
+            }, idempotencyKey?: string): Promise<import("./openfga").OpenFgaStore>;
+            get(store: string): Promise<import("./openfga").OpenFgaStore>;
+        };
+        authorizationModels: {
+            list(store: string): Promise<{
+                authorization_models: import("./openfga").OpenFgaAuthorizationModel[];
+            }>;
+            write(store: string, body: import("./openfga").WriteOpenFgaModelBody): Promise<{
+                authorization_model_id: string;
+            }>;
+            get(store: string, modelId: string): Promise<{
+                authorization_model: import("./openfga").OpenFgaAuthorizationModel;
+            }>;
+        };
+        check(store: string, body: import("./openfga").OpenFgaCheckBody): Promise<{
+            allowed: boolean;
+        }>;
+        batchCheck(store: string, body: import("./openfga").OpenFgaBatchCheckBody): Promise<{
+            result: Record<string, {
+                allowed: boolean;
+            }>;
+        }>;
+        expand(store: string, body: import("./openfga").OpenFgaExpandBody): Promise<{
+            tree: {
+                root: Record<string, unknown>;
+            };
+        }>;
+        listObjects(store: string, body: import("./openfga").OpenFgaListObjectsBody): Promise<{
+            objects: string[];
+        }>;
+        read(store: string, body?: import("./openfga").OpenFgaReadBody): Promise<{
+            tuples: import("./openfga").OpenFgaTuple[];
+            continuation_token: string;
+        }>;
+        write(store: string, body: import("./openfga").OpenFgaWriteBody): Promise<Record<string, never>>;
+    };
+    connectors: {
+        list(): Promise<{
+            object: "list";
+            data: import("./connectors").CommunityConnector[];
+            has_more: false;
+        }>;
+        create(body: import("./connectors").CreateCommunityConnectorBody, idempotencyKey?: string): Promise<import("./connectors").CommunityConnector>;
+        get(id: string): Promise<import("./connectors").CommunityConnector>;
+        update(id: string, body: import("./connectors").UpdateCommunityConnectorBody): Promise<import("./connectors").CommunityConnector>;
+        delete(id: string): Promise<{
+            object: "connector";
+            id: string;
+            deleted: true;
+        }>;
+        publish(id: string): Promise<import("./connectors").CommunityConnector>;
+        unlist(id: string): Promise<import("./connectors").CommunityConnector>;
+        setSharedCredentials(id: string, body: import("./connectors").ConnectorSharedCredentialsBody): Promise<import("./connectors").CommunityConnector>;
+        install(slug: string, body: import("./connectors").InstallConnectorBody): Promise<import("./connectors").ConnectorInstall>;
+        review(slug: string, body: {
+            rating: number;
+            body?: string;
+        }): Promise<import("./connectors").ConnectorReview>;
+        directory(params?: import("./connectors").ConnectorDirectoryParams): Promise<{
+            object: "list";
+            data: import("./connectors").ConnectorDirectoryEntry[];
+        }>;
+    };
+    notifications: {
+        send(body: import("./notifications").SendNotificationBody, idempotencyKey?: string): Promise<import("./notifications").SentNotification>;
+        categories: {
+            list(): Promise<{
+                object: "list";
+                data: import("./notifications").NotificationCategory[];
+            }>;
+            create(body: {
+                key: string;
+                label: string;
+            }): Promise<import("./notifications").NotificationCategory>;
+            update(key: string, body: {
+                label: string;
+            }): Promise<import("./notifications").NotificationCategory>;
+            delete(key: string): Promise<{
+                object: "notification_category";
+                key: string;
+                deleted: boolean;
+            }>;
+        };
+        templates: {
+            list(): Promise<{
+                object: "list";
+                data: import("./notifications").NotificationTemplate[];
+            }>;
+            create(body: import("./notifications").CreateNotificationTemplateBody): Promise<import("./notifications").NotificationTemplate>;
+            get(name: string): Promise<import("./notifications").NotificationTemplate>;
+            update(name: string, body: import("./notifications").UpdateNotificationTemplateBody): Promise<import("./notifications").NotificationTemplate>;
+            delete(name: string): Promise<{
+                object: "notification_template";
+                name: string;
+                deleted: boolean;
+            }>;
+        };
+    };
+    auditEvents: {
+        create(body: import("./audit-events").CreateCustomAuditEventBody, idempotencyKey?: string): Promise<import("./audit-events").CustomAuditEvent>;
+        createBatch(events: import("./audit-events").CreateCustomAuditEventBody[], idempotencyKey?: string): Promise<{
+            object: "list";
+            data: import("./audit-events").CustomAuditEvent[];
+        }>;
+        list(params?: import("./audit-events").ListCustomAuditEventsParams): Promise<import("./types").CursorPage<import("./audit-events").CustomAuditEvent>>;
+        export(params?: import("./audit-events").ExportCustomAuditEventsParams): Promise<string>;
+        deleteAll(params?: {
+            organization_id?: string;
+            action?: string;
+        }): Promise<{
+            object: "audit_events.bulk_delete";
+            deleted: number;
+        }>;
+    };
+    events: {
+        list(params?: import("./activity").ListActivityEventsParams): Promise<import("./activity").ActivityEventsPage>;
+    };
+    usage: {
+        get(params?: {
+            days?: number;
+        }): Promise<import("./activity").UsageReport>;
+    };
+    configChangelog: {
+        list(params?: import("./activity").ListConfigChangelogParams): Promise<{
+            object: "config_changelog";
+            data: import("./activity").ConfigChangelogEntry[];
+            has_more: boolean;
+            next_cursor: string | null;
+        }>;
+    };
+    pca: {
+        attestors: {
+            get(): Promise<import("./pca").PcaAdminAttestors>;
+            set(trustedAttestorKeys: string[]): Promise<import("./pca").PcaAdminAttestors>;
+        };
+        freeze(body?: {
+            reason?: string;
+        }): Promise<import("./pca").PcaAdminFreeze>;
+        unfreeze(): Promise<import("./pca").PcaAdminFreeze>;
+        revoke(body: {
+            grant_ref: string;
+            cap_id: string;
+        }): Promise<import("./pca").PcaAdminRevocation>;
+        denyStepUp(id: string, body?: {
+            reason?: string;
+        }): Promise<import("./pca").PcaAdminStepUp>;
+    };
+    mcp: {
+        describe(): Promise<import("./mcp").McpServerDescriptor>;
+        rpc: <R = Record<string, unknown>>(method: string, params?: unknown, id?: string | number) => Promise<import("./mcp").McpJsonRpcResponse<R>>;
+        listTools(): Promise<import("./mcp").McpJsonRpcResponse<{
+            tools: Array<Record<string, unknown>>;
+        }>>;
+        callTool(name: string, args?: Record<string, unknown>): Promise<import("./mcp").McpJsonRpcResponse<import("./mcp").McpToolCallResult>>;
+    };
+    mcpConnector: {
+        get(): Promise<import("./mcp").McpConnector>;
+        update(body: import("./mcp").UpdateMcpConnectorBody, idempotencyKey?: string): Promise<import("./mcp").McpConnector>;
+        disable(): Promise<import("./mcp").McpConnector>;
+    };
+    legacyAuthConnection: {
+        get(): Promise<import("./legacy-auth").LegacyAuthConnection>;
+        set(body: import("./legacy-auth").PutLegacyAuthConnectionBody, idempotencyKey?: string): Promise<import("./legacy-auth").LegacyAuthConnection>;
+        delete(): Promise<{
+            object: "legacy_auth_connection";
+            deleted: boolean;
+        }>;
+    };
+    redirectUrls: {
+        list(): Promise<import("./types").ListPage<import("./redirect-urls").RedirectUrl> & {
+            next_cursor?: string | null;
+        }>;
+        create(url: string, idempotencyKey?: string): Promise<import("./redirect-urls").RedirectUrl>;
+        get(id: string): Promise<import("./redirect-urls").RedirectUrl>;
+        delete(id: string): Promise<{
+            object: "redirect_url";
+            id: string;
+            deleted: true;
+        }>;
+    };
+    sessionExchangeApps: {
+        list(): Promise<import("./types").ListPage<import("./session-exchange-apps").SessionExchangeApp> & {
+            next_cursor?: string | null;
+        }>;
+        create(body: import("./session-exchange-apps").CreateSessionExchangeAppBody, idempotencyKey?: string): Promise<import("./session-exchange-apps").SessionExchangeApp>;
+        get(id: string): Promise<import("./session-exchange-apps").SessionExchangeApp>;
+        update(id: string, body: import("./session-exchange-apps").UpdateSessionExchangeAppBody): Promise<import("./session-exchange-apps").SessionExchangeApp>;
+        delete(id: string): Promise<{
+            object: "session_exchange_app";
+            id: string;
+            deleted: true;
+        }>;
+    };
+    tickets: {
+        create(body: import("./tickets").CreateTicketBody, idempotencyKey?: string): Promise<import("./tickets").CapabilityTicket>;
+        redeem<P = unknown>(body: import("./tickets").RedeemTicketBody): Promise<import("./tickets").TicketRedemption<P>>;
+    };
+    testMode: {
+        testInstance(body?: {
+            rotate_secret?: boolean;
+        }): Promise<import("./test-mode").TestInstance>;
+        purgeTestUsers(body?: {
+            limit?: number;
+        }): Promise<import("./test-mode").TestUsersPurgeResult>;
+        createTestingToken(): Promise<import("./test-mode").TestingToken>;
+    };
+    diagnostics: {
+        loginReadiness(params: import("./diagnostics").LoginReadinessParams): Promise<import("./diagnostics").LoginReadiness>;
+        requestInspector(params: import("./diagnostics").RequestInspectorParams): Promise<import("./diagnostics").RequestInspection>;
+    };
 };
+/** Every resource namespace of the management client. */
+export type AtlasClientNamespaces = ReturnType<typeof buildNamespaces>;
 /** The fully typed client instance `createAtlasClient` returns. */
-export type AtlasClient = ReturnType<typeof createAtlasClient>;
-export type { AtlasClientConfig } from './request';
+export interface AtlasClient extends AtlasClientNamespaces {
+    /**
+     * A copy of this client with some settings changed — e.g.
+     * `atlas.withOptions({ strict: true }).users.update(...)` for one strict call.
+     */
+    withOptions(overrides: AtlasRequestSettings): AtlasClient;
+}
+export type { AtlasClientConfig, AtlasRequestSettings, UnknownFieldsEvent, RawBody, } from './request';
 export { DEFAULT_API_URL } from './request';
+export { AtlasErrorCodes, type AtlasErrorCode } from './error';
+export { createAtlasPlatformClient } from './platform';
+export type { AtlasPlatformClient, AtlasPlatformClientConfig } from './platform';
 export { AtlasApiError, type AtlasErrorItem } from './error';
 export { paginate, collect } from './paginate';
 export * from './types';
@@ -836,3 +1259,22 @@ export * from './instance';
 export * from './instance-security';
 export * from './tokens';
 export * from './captcha';
+export * from './design';
+export * from './entitlement-overrides';
+export * from './org-ldap-connections';
+export * from './organization-settings-schema';
+export * from './email-addresses';
+export * from './openfga';
+export * from './connectors';
+export * from './notifications';
+export * from './audit-events';
+export * from './activity';
+export * from './pca';
+export * from './mcp';
+export * from './legacy-auth';
+export * from './redirect-urls';
+export * from './session-exchange-apps';
+export * from './tickets';
+export * from './test-mode';
+export * from './diagnostics';
+export * from './platform';