@atlasauth/backend 0.24.0 → 0.25.0

package/dist/client/index.d.ts

@@ -29,6 +29,7 @@ declare function buildNamespaces(request: RequestFn): {
         unban(id: string): Promise<import("./users").User>;
         lock(id: string, body?: {
             duration_in_seconds?: number;
+            reason?: string;
         }): Promise<import("./users").User>;
         unlock(id: string): Promise<import("./users").User>;
         flagReferral(id: string, body?: {
@@ -108,6 +109,15 @@ declare function buildNamespaces(request: RequestFn): {
         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>;
+        listDeviceKeys(id: string): Promise<{
+            object: "list";
+            data: import("./users").DeviceKey[];
+        }>;
+        deleteDeviceKey(id: string, keyId: string): Promise<{
+            object: "device_key";
+            id: string;
+            deleted: true;
+        }>;
         deletePasskey(id: string, passkeyId: string): Promise<{
             object: "passkey";
             id: string;
@@ -122,6 +132,90 @@ declare function buildNamespaces(request: RequestFn): {
         }>;
         acknowledgeErasure(id: string, body: import("./users").UserErasureAckBody, idempotencyKey?: string): Promise<import("./users").UserErasureAck>;
         erasureExport(id: string): Promise<import("./users").UserErasureExport>;
+        createLink(id: string, body: import("./users").UserLinkBody, idempotencyKey?: string): Promise<import("./users").UserLink>;
+        search: {
+            query(body: import("./users").UserSearchBody): Promise<import("./types").CursorPage<import("./users").User> & {
+                total_count?: number;
+            }>;
+            export(body: import("./users").UserSearchExportBody): Promise<string>;
+            views: {
+                list(): Promise<{
+                    object: "list";
+                    data: import("./users").UserSearchView[];
+                    has_more: boolean;
+                }>;
+                create(body: import("./users").UserSearchViewBody & {
+                    name: string;
+                }, idempotencyKey?: string): Promise<import("./users").UserSearchView>;
+                update(id: string, body: import("./users").UserSearchViewBody): Promise<import("./users").UserSearchView>;
+                delete(id: string): Promise<{
+                    object: "user_search_view";
+                    id: string;
+                    deleted: true;
+                }>;
+            };
+        };
+        requiredActions: {
+            request(id: string, body: import("./users").RequiredActionBody, idempotencyKey?: string): Promise<import("./users").RequiredAction>;
+            list(id: string): Promise<{
+                object: "list";
+                data: import("./users").RequiredAction[];
+                has_more: boolean;
+            }>;
+            clear(id: string, requiredActionId: string, idempotencyKey?: string): Promise<{
+                object: "required_action";
+                id: string;
+                deleted: true;
+            }>;
+            bulk(body: import("./users").RequiredActionBody & ({
+                organization_id: string;
+            } | {
+                user_ids: string[];
+            }), idempotencyKey?: string): Promise<import("./users").RequiredActionBulkResult>;
+        };
+        notes: {
+            list(id: string): Promise<{
+                object: "list";
+                data: import("./users").UserNote[];
+                has_more: boolean;
+                total_count: number;
+            }>;
+            create(id: string, body: {
+                body: string;
+                pinned?: boolean;
+            }, idempotencyKey?: string): Promise<import("./users").UserNote>;
+            update(id: string, noteId: string, body: {
+                body?: string;
+                pinned?: boolean;
+            }, idempotencyKey?: string): Promise<import("./users").UserNote>;
+            delete(id: string, noteId: string, idempotencyKey?: string): Promise<{
+                object: "user_note";
+                id: string;
+                deleted: true;
+            }>;
+        };
+        history(id: string, params?: {
+            limit?: number;
+            starting_after?: string;
+            action?: string[];
+        }): Promise<import("./users").UserHistoryPage>;
+        minorStatus(id: string): Promise<import("./users").MinorStatus>;
+        assessMinor(id: string): Promise<import("./users").MinorStatus>;
+        guardians: {
+            request(id: string, body: {
+                email?: string;
+                guardian_user_id?: string;
+                relationship?: string;
+                send_email?: boolean;
+            }, idempotencyKey?: string): Promise<import("./users").GuardianLink & {
+                consent_url: string;
+                emailed: boolean;
+            }>;
+            approve(id: string, linkId: string, body?: {
+                note?: string;
+            }): Promise<import("./users").GuardianLink>;
+            revoke(id: string, linkId: string): Promise<import("./users").GuardianLink>;
+        };
         deletion: {
             schedule(id: string, body?: {
                 grace_seconds?: number;
@@ -279,6 +373,26 @@ declare function buildNamespaces(request: RequestFn): {
                 deleted: true;
             }>;
         };
+        webhookEndpoints: {
+            list(orgId: string): Promise<import("./types").ListPage<import("./webhooks").WebhookEndpoint>>;
+            get(orgId: string, endpointId: string): Promise<import("./webhooks").WebhookEndpoint>;
+            create(orgId: string, body: import("./organizations").OrganizationWebhookEndpointBody & {
+                url: string;
+            }, idempotencyKey?: string): Promise<import("./webhooks").WebhookEndpointWithSecret>;
+            update(orgId: string, endpointId: string, body: import("./organizations").OrganizationWebhookEndpointBody): Promise<import("./webhooks").WebhookEndpoint>;
+            delete(orgId: string, endpointId: string): Promise<{
+                object: "webhook_endpoint";
+                id: string;
+                deleted: true;
+            }>;
+            rotateSecret(orgId: string, endpointId: string): Promise<{
+                object: "webhook_secret";
+                secret: string;
+                overlap_seconds: number;
+                previous_secret_expires_at: number | null;
+            }>;
+            deliveries(orgId: string, endpointId: string, query?: Record<string, string | number | undefined>): Promise<import("./types").ListPage<import("./webhooks").WebhookDelivery>>;
+        };
         branding: {
             get(orgId: string): Promise<import("./organizations").OrganizationBranding>;
             update(orgId: string, body: import("./organizations").UpdateOrganizationBrandingBody): Promise<import("./organizations").OrganizationBranding>;
@@ -366,8 +480,39 @@ declare function buildNamespaces(request: RequestFn): {
             deleted: true;
             note: string;
         }>;
+        appSettings: {
+            get(id: string): Promise<import("./oauth-clients").OAuthClientAppSettings>;
+            update(id: string, body: import("./oauth-clients").OAuthClientAppSettingsPatch): Promise<import("./oauth-clients").OAuthClientAppSettings>;
+        };
         listBackchannelDeliveries(id: string, query?: import("./oauth-clients").BackchannelDeliveriesQuery): Promise<import("./oauth-clients").BackchannelLogoutDeliveryPage>;
         testBackchannelLogout(id: string): Promise<import("./oauth-clients").BackchannelLogoutTest>;
+        setDelegatedUi(id: string, body: {
+            login_url?: string | null;
+            consent_url?: string | null;
+        }): Promise<{
+            object: "oauth_client_delegated_ui";
+            client_id: string;
+            login_url: string | null;
+            consent_url: string | null;
+        }>;
+        loginRequests: {
+            get(loginChallenge: string): Promise<import("./oauth-clients").DelegatedLoginRequest>;
+            accept(loginChallenge: string, body: {
+                subject: string;
+                remember?: boolean;
+                amr?: string[];
+                acr?: string;
+            }): Promise<import("./oauth-clients").DelegatedRedirect>;
+            reject(loginChallenge: string, body?: import("./oauth-clients").DelegatedReject): Promise<import("./oauth-clients").DelegatedRedirect>;
+        };
+        consentRequests: {
+            get(consentChallenge: string): Promise<import("./oauth-clients").DelegatedConsentRequest>;
+            accept(consentChallenge: string, body?: {
+                grant_scope?: string[];
+                remember?: boolean;
+            }): Promise<import("./oauth-clients").DelegatedRedirect>;
+            reject(consentChallenge: string, body?: import("./oauth-clients").DelegatedReject): Promise<import("./oauth-clients").DelegatedRedirect>;
+        };
         initialAccessTokens: {
             list(): Promise<import("./types").ListPage<import("./oauth-clients").OAuthInitialAccessToken>>;
             create(body?: import("./oauth-clients").CreateInitialAccessTokenBody): Promise<import("./oauth-clients").OAuthInitialAccessToken & {
@@ -376,6 +521,24 @@ declare function buildNamespaces(request: RequestFn): {
             }>;
             revoke(id: string): Promise<import("./oauth-clients").OAuthInitialAccessToken>;
         };
+        trustedIssuers: {
+            list(clientId: string): Promise<import("./types").ListPage<import("./oauth-clients").TrustedIssuer>>;
+            create(clientId: string, body: import("./oauth-clients").TrustedIssuerInput): Promise<import("./oauth-clients").TrustedIssuer>;
+            delete(clientId: string, issuerId: string): Promise<{
+                object: "oauth_trusted_issuer";
+                id: string;
+                deleted: true;
+            }>;
+        };
+        workloadIdentity: {
+            presets(): Promise<import("./types").ListPage<import("./oauth-clients").WorkloadPreset>>;
+            cloudTrust(query: {
+                provider: "aws" | "gcp" | "azure";
+                audience: string;
+                subject: string;
+                tenant_id?: string;
+            }): Promise<Record<string, unknown>>;
+        };
         grants: {
             list(clientId: string): Promise<import("./types").ListPage<import("./oauth-clients").ClientGrant>>;
             create(clientId: string, body: {
@@ -389,6 +552,83 @@ declare function buildNamespaces(request: RequestFn): {
             }>;
         };
     };
+    passkeyApi: {
+        registrationInit(body: {
+            user_id: string;
+            username?: string;
+            display_name?: string;
+        }): Promise<{
+            object: "passkey_registration_options";
+            options: Record<string, unknown>;
+        }>;
+        registrationFinalize(body: import("./passkey-api").PasskeyRegistrationFinalize): Promise<import("./passkey-api").ExternalPasskey>;
+        loginInit(body?: {
+            user_id?: string;
+        }): Promise<{
+            object: "passkey_login_options";
+            handle: string;
+            options: Record<string, unknown>;
+        }>;
+        loginFinalize(body: import("./passkey-api").PasskeyLoginFinalize): Promise<{
+            object: "passkey_login_result";
+            verified: true;
+            user_id: string;
+            credential_id: string;
+            passkey_id: string;
+            user_verified: boolean;
+            cloned_warning: boolean;
+        }>;
+        list(userId: string): Promise<import("./types").ListPage<import("./passkey-api").ExternalPasskey>>;
+        delete(userId: string, id: string): Promise<{
+            object: "external_passkey";
+            id: string;
+            deleted: true;
+        }>;
+        usage(): Promise<{
+            object: "passkey_api_usage";
+            passkeys: number;
+        }>;
+    };
+    vc: {
+        credentialTypes: {
+            list(): Promise<import("./types").ListPage<import("./vc").VcCredentialType>>;
+            create(body: import("./vc").CreateVcCredentialTypeBody): Promise<import("./vc").VcCredentialType>;
+            get(id: string): Promise<import("./vc").VcCredentialType>;
+            delete(id: string): Promise<{
+                object: "vc_credential_type";
+                id: string;
+                deleted: true;
+            }>;
+        };
+        createOffer(body: {
+            credential_type_id: string;
+            user_id: string;
+            tx_code?: string;
+            expires_in_seconds?: number;
+        }): Promise<import("./vc").VcOffer>;
+        credentials: {
+            list(query?: {
+                user_id?: string;
+            }): Promise<import("./types").ListPage<import("./vc").VcCredential>>;
+            revoke(id: string): Promise<import("./vc").VcCredential>;
+        };
+        presentationRequests: {
+            create(body: {
+                vct: string;
+                format?: import("./vc").VcFormat;
+                iaca_roots?: string[];
+                claims?: string[];
+                trusted_issuers?: Array<{
+                    issuer: string;
+                    jwks: {
+                        keys: Record<string, unknown>[];
+                    };
+                }>;
+                expires_in_seconds?: number;
+            }): Promise<import("./vc").VcPresentationRequest>;
+            get(id: string): Promise<import("./vc").VcPresentationRequest>;
+        };
+    };
     resourceServers: {
         list(): Promise<import("./types").ListPage<import("./resource-servers").ResourceServer>>;
         get(id: string): Promise<import("./resource-servers").ResourceServer>;
@@ -502,6 +742,85 @@ declare function buildNamespaces(request: RequestFn): {
     attackProtection: {
         get(): Promise<import("./attack-protection").AttackProtection>;
         update(body: import("./attack-protection").UpdateAttackProtectionBody): Promise<import("./attack-protection").AttackProtection>;
+        setAppAttestationSecret(secret: string, kind?: "play_integrity" | "devicecheck"): Promise<{
+            object: "app_attestation_secret";
+            set: true;
+        }>;
+        removeAppAttestationSecret(kind?: "play_integrity" | "devicecheck"): Promise<{
+            object: "app_attestation_secret";
+            deleted: true;
+        }>;
+    };
+    mfaFactors: {
+        setYubicoSecret(secret: string): Promise<{
+            object: "yubico_secret";
+            set: true;
+        }>;
+        removeYubicoSecret(): Promise<{
+            object: "yubico_secret";
+            deleted: true;
+        }>;
+        setDuoSecret(secret: string): Promise<{
+            object: "duo_secret";
+            set: true;
+        }>;
+        removeDuoSecret(): Promise<{
+            object: "duo_secret";
+            deleted: true;
+        }>;
+        duoHealthCheck(): Promise<{
+            object: "duo_health_check";
+            ok: boolean;
+            message: string;
+        }>;
+        setSmartCardSecret(secret: string): Promise<{
+            object: "smart_card_secret";
+            set: true;
+        }>;
+        removeSmartCardSecret(): Promise<{
+            object: "smart_card_secret";
+            deleted: true;
+        }>;
+        yubikeys: {
+            list(): Promise<{
+                object: "list";
+                data: import("./mfa-factors").Yubikey[];
+            }>;
+            register(body: {
+                publicId: string;
+                aesKey: string;
+                privateId?: string;
+                label?: string;
+                userId?: string;
+            }): Promise<import("./mfa-factors").Yubikey>;
+            remove(id: string): Promise<{
+                object: "yubikey";
+                id: string;
+                deleted: true;
+            }>;
+        };
+        smartCardMappings: {
+            list(userId: string): Promise<{
+                object: "list";
+                data: import("./mfa-factors").SmartCardMapping[];
+            }>;
+            add(userId: string, body: {
+                kind: import("./mfa-factors").SmartCardMappingKind;
+                value: string;
+                issuer?: string;
+                label?: string;
+            }): Promise<import("./mfa-factors").SmartCardMapping>;
+            remove(userId: string, mappingId: string): Promise<{
+                object: "smartcard_mapping";
+                id: string;
+                deleted: true;
+            }>;
+        };
+        resetSecurityQuestions(userId: string): Promise<{
+            object: "security_questions";
+            user_id: string;
+            deleted: boolean;
+        }>;
     };
     actorTokens: {
         create(body: import("./actor-tokens").CreateActorTokenBody, idempotencyKey?: string): Promise<import("./actor-tokens").ActorToken>;
@@ -630,6 +949,58 @@ declare function buildNamespaces(request: RequestFn): {
         setForUser(userId: string, body: import("./app-roles").SetUserAppRolesBody): Promise<import("./app-roles").UserAppRoles>;
         removeFromUser(userId: string, idOrKey: string): Promise<import("./app-roles").UserAppRoles>;
     };
+    groups: {
+        list(): Promise<import("./types").ListPage<import("./groups").Group>>;
+        get(idOrSlug: string): Promise<import("./groups").Group>;
+        create(body: import("./groups").GroupBody & {
+            slug: string;
+            name: string;
+        }, idempotencyKey?: string): Promise<import("./groups").Group>;
+        update(idOrSlug: string, body: import("./groups").GroupBody): Promise<import("./groups").Group>;
+        delete(idOrSlug: string): Promise<{
+            object: "group";
+            id: string;
+            deleted: true;
+        }>;
+        listMembers(idOrSlug: string, query?: {
+            limit?: number;
+            starting_after?: string;
+        }): Promise<import("./types").ListPage<import("./groups").GroupMember> & {
+            next_cursor: string | null;
+        }>;
+        addMembers(idOrSlug: string, userIds: string[]): Promise<{
+            added: number;
+            promoted: number;
+            already_member: number;
+            skipped: number;
+        }>;
+        removeMembers(idOrSlug: string, userIds: string[]): Promise<{
+            removed: number;
+        }>;
+        reapply(idOrSlug: string): Promise<{
+            matched: number;
+            added: number;
+            removed: number;
+        }>;
+        forUser(userId: string): Promise<import("./types").ListPage<import("./groups").Group>>;
+        rules: {
+            list(): Promise<import("./types").ListPage<import("./groups").GroupRule>>;
+            get(id: string): Promise<import("./groups").GroupRule>;
+            create(body: import("./groups").GroupRuleBody & {
+                name: string;
+                condition: Record<string, unknown>;
+                actions: import("./groups").GroupRuleAction[];
+            }, idempotencyKey?: string): Promise<import("./groups").GroupRule>;
+            update(id: string, body: import("./groups").GroupRuleBody): Promise<import("./groups").GroupRule>;
+            delete(id: string): Promise<{
+                object: "group_rule";
+                id: string;
+                deleted: true;
+            }>;
+            apply(id: string): Promise<import("./groups").GroupRuleResult>;
+            applyAll(): Promise<import("./types").ListPage<import("./groups").GroupRuleResult>>;
+        };
+    };
     machines: {
         list(query?: import("./machines").ListMachinesQuery): Promise<import("./machines").MachineListPage>;
         create(body: import("./machines").CreateMachineBody, idempotencyKey?: string): Promise<import("./machines").MachineWithSecret>;
@@ -816,6 +1187,66 @@ declare function buildNamespaces(request: RequestFn): {
     riskBasedMfa: {
         get(): Promise<import("./risk-based-mfa").RiskBasedMfa>;
         update(body: import("./risk-based-mfa").UpdateRiskBasedMfaBody): Promise<import("./risk-based-mfa").RiskBasedMfa>;
+        fraudLookup(body: import("./risk-based-mfa").FraudLookupBody): Promise<import("./risk-based-mfa").FraudLookup>;
+        setReputationSecret(secret: string, provider?: "ipqs" | "spur" | "minfraud"): Promise<{
+            object: "risk_reputation_secret";
+            provider: string;
+            set: true;
+        }>;
+        removeReputationSecret(provider?: "ipqs" | "spur" | "minfraud"): Promise<{
+            object: "risk_reputation_secret";
+            provider: string;
+            deleted: true;
+        }>;
+    };
+    riskEvents: {
+        list(query?: {
+            user_id?: string;
+            level?: import("./risk-based-mfa").RiskLevel;
+            limit?: number;
+            before?: string;
+        }): Promise<{
+            object: "list";
+            data: import("./risk-based-mfa").RiskEvent[];
+        }>;
+        metrics(query?: {
+            days?: number;
+        }): Promise<import("./risk-based-mfa").RiskEventMetrics>;
+        feedback(id: string, verdict: "legit" | "fraud"): Promise<import("./risk-based-mfa").RiskEvent>;
+    };
+    ssf: {
+        streams: {
+            list(): Promise<{
+                object: "list";
+                data: import("./ssf").SsfStream[];
+            }>;
+            create(body: import("./ssf").CreateSsfStreamBody): Promise<import("./ssf").SsfStreamCreated>;
+            get(id: string): Promise<import("./ssf").SsfStream>;
+            update(id: string, body: import("./ssf").UpdateSsfStreamBody): Promise<import("./ssf").SsfStream>;
+            delete(id: string): Promise<void>;
+            verify(id: string, state?: string): Promise<{
+                object: "ssf_verification";
+                stream_id: string;
+                state: string;
+            }>;
+            events(id: string, query?: {
+                limit?: number;
+            }): Promise<{
+                object: "list";
+                data: import("./ssf").SsfEventRecord[];
+            }>;
+        };
+        receivers: {
+            list(): Promise<{
+                object: "list";
+                data: import("./ssf").SsfReceiver[];
+            }>;
+            create(body: import("./ssf").CreateSsfReceiverBody): Promise<import("./ssf").SsfReceiver>;
+            update(id: string, body: Partial<Omit<import("./ssf").CreateSsfReceiverBody, "issuer">> & {
+                enabled?: boolean;
+            }): Promise<import("./ssf").SsfReceiver>;
+            delete(id: string): Promise<void>;
+        };
     };
     botSignals: {
         list(query?: import("./bot-signals").BotExportParams): Promise<import("./bot-signals").BotExportPage<import("./bot-signals").BotSignal>>;
@@ -833,6 +1264,162 @@ declare function buildNamespaces(request: RequestFn): {
             deleted: true;
         }>;
     };
+    networkZones: {
+        list(): Promise<import("./types").ListPage<import("./network-zones").NetworkZone>>;
+        get(id: string): Promise<import("./network-zones").NetworkZone>;
+        create(body: import("./network-zones").CreateNetworkZoneBody, idempotencyKey?: string): Promise<import("./network-zones").NetworkZone>;
+        update(id: string, body: import("./network-zones").UpdateNetworkZoneBody): Promise<import("./network-zones").NetworkZone>;
+        delete(id: string): Promise<{
+            object: "network_zone";
+            id: string;
+            deleted: true;
+        }>;
+        check(id: string, ip: string): Promise<import("./network-zones").NetworkZoneCheck>;
+    };
+    accessPolicies: {
+        list(): Promise<import("./types").ListPage<import("./access-policies").AccessPolicy>>;
+        get(id: string): Promise<import("./access-policies").AccessPolicy>;
+        create(body: import("./access-policies").CreateAccessPolicyBody, idempotencyKey?: string): Promise<import("./access-policies").AccessPolicy>;
+        update(id: string, body: import("./access-policies").UpdateAccessPolicyBody): Promise<import("./access-policies").AccessPolicy>;
+        delete(id: string): Promise<{
+            object: "access_policy";
+            id: string;
+            deleted: true;
+        }>;
+        simulate(body: import("./access-policies").SimulateAccessBody): Promise<import("./access-policies").AccessPolicySimulation>;
+    };
+    abac: {
+        list(): Promise<import("./types").ListPage<import("./abac").AbacPolicy>>;
+        get(id: string): Promise<import("./abac").AbacPolicy>;
+        create(body: import("./abac").CreateAbacPolicyBody, idempotencyKey?: string): Promise<import("./abac").AbacPolicy>;
+        update(id: string, body: import("./abac").UpdateAbacPolicyBody): Promise<import("./abac").AbacPolicy>;
+        delete(id: string): Promise<{
+            object: "abac_policy";
+            id: string;
+            deleted: true;
+        }>;
+        versions(id: string): Promise<import("./types").ListPage<import("./abac").AbacPolicyVersion>>;
+        test(id: string, body?: {
+            version?: number;
+            source?: string;
+            tests?: import("./abac").AbacPolicyTestCase[];
+        }): Promise<import("./abac").AbacTestRun>;
+        evaluate(body: import("./abac").AbacEvaluateBody): Promise<import("./abac").AbacDecision>;
+        isAllowed(body: import("./abac").AbacEvaluateBody): Promise<boolean>;
+        authzenEvaluation(body: import("./abac").AuthzenEvaluation): Promise<{
+            decision: boolean;
+            context?: Record<string, unknown>;
+        }>;
+        authzenEvaluations(body: import("./abac").AuthzenEvaluation & {
+            evaluations?: import("./abac").AuthzenEvaluation[];
+            options?: {
+                evaluations_semantic?: "execute_all" | "deny_on_first_deny" | "permit_on_first_permit";
+            };
+        }): Promise<{
+            evaluations: Array<{
+                decision: boolean;
+            }>;
+        }>;
+    };
+    resources: {
+        types: {
+            list(): Promise<import("./types").ListPage<import("./resources").ResourceType>>;
+            get(key: string): Promise<import("./resources").ResourceType>;
+            create(body: import("./resources").CreateResourceTypeBody, idempotencyKey?: string): Promise<import("./resources").ResourceType>;
+            update(key: string, body: Partial<Omit<import("./resources").CreateResourceTypeBody, "key">>): Promise<import("./resources").ResourceType>;
+            delete(key: string): Promise<{
+                object: "resource_type";
+                key: string;
+                deleted: true;
+            }>;
+        };
+        list(query?: {
+            type?: string;
+            parent_id?: string;
+            limit?: number;
+        }): Promise<import("./types").ListPage<import("./resources").Resource>>;
+        get(id: string): Promise<import("./resources").Resource>;
+        upsert(body: import("./resources").UpsertResourceBody): Promise<import("./resources").Resource>;
+        sync(resources: import("./resources").UpsertResourceBody[]): Promise<import("./types").ListPage<import("./resources").Resource>>;
+        delete(id: string): Promise<{
+            object: "resource";
+            id: string;
+            deleted: true;
+        }>;
+        assignments: {
+            list(query?: {
+                resource_id?: string;
+                subject_type?: string;
+                subject_id?: string;
+            }): Promise<import("./types").ListPage<import("./resources").ResourceRoleAssignment>>;
+            assign(body: {
+                resource: import("./resources").ResourceRef;
+                subject: import("./resources").ResourceSubject;
+                role: string;
+                inherit?: boolean;
+            }): Promise<import("./resources").ResourceRoleAssignment>;
+            revoke(id: string): Promise<{
+                object: "resource_role_assignment";
+                id: string;
+                deleted: true;
+            }>;
+        };
+        check(body: import("./resources").ResourceCheckBody): Promise<import("./resources").ResourceCheck>;
+        can(body: import("./resources").ResourceCheckBody): Promise<boolean>;
+        checkBatch(checks: import("./resources").ResourceCheckBody[]): Promise<import("./types").ListPage<import("./resources").ResourceCheck>>;
+        accessible(body: {
+            subject: import("./resources").ResourceSubject;
+            permission: string;
+            type?: string;
+            groups?: string[];
+            limit?: number;
+        }): Promise<import("./types").ListPage<import("./resources").Resource>>;
+    };
+    orgRoleGrants: {
+        list(query?: {
+            grantor_org_id?: string;
+            grantee_org_id?: string;
+            status?: "active";
+        }): Promise<import("./types").ListPage<import("./org-role-grants").OrgRoleGrant>>;
+        create(body: {
+            grantor_org_id: string;
+            grantee_org_id: string;
+            role_keys: string[];
+        }): Promise<import("./org-role-grants").OrgRoleGrant>;
+        get(id: string): Promise<import("./org-role-grants").OrgRoleGrant>;
+        update(id: string, body: {
+            role_keys: string[];
+        }): Promise<import("./org-role-grants").OrgRoleGrant>;
+        revoke(id: string): Promise<import("./org-role-grants").OrgRoleGrant>;
+        listDelegations(id: string): Promise<import("./types").ListPage<import("./org-role-grants").OrgRoleDelegation>>;
+        delegate(id: string, body: {
+            user_id: string;
+            role_key: string;
+        }): Promise<import("./org-role-grants").OrgRoleDelegation>;
+        undelegate(id: string, delegationId: string): Promise<{
+            object: "org_role_delegation";
+            id: string;
+            deleted: true;
+        }>;
+        effective(query: {
+            user_id: string;
+            organization_id?: string;
+        }): Promise<import("./types").ListPage<import("./org-role-grants").EffectiveDelegatedRole>>;
+    };
+    devices: {
+        list(query?: {
+            user_id?: string;
+            source?: string;
+        }): Promise<import("./types").ListPage<import("./devices").Device>>;
+        get(id: string): Promise<import("./devices").Device>;
+        report(body: import("./devices").DeviceReportBody): Promise<import("./devices").Device>;
+        ingestPosture(devices: import("./devices").DeviceReportBody[]): Promise<import("./types").ListPage<import("./devices").Device>>;
+        remove(id: string): Promise<{
+            object: "device";
+            id: string;
+            deleted: true;
+        }>;
+    };
     managedWaf: {
         get(): Promise<import("./managed-waf").ManagedWaf>;
         status(): Promise<import("./managed-waf").ManagedWafStatus>;
@@ -922,18 +1509,57 @@ declare function buildNamespaces(request: RequestFn): {
     };
     actions: {
         list(): Promise<import("./types").ListPage<import("./actions").Action>>;
-        create(body: import("./actions").CreateActionBody, idempotencyKey?: string): Promise<import("./actions").Action>;
+        create(body: import("./actions").CreateActionBody, idempotencyKey?: string): Promise<import("./actions").ActionWithSecret>;
         get(id: string): Promise<import("./actions").Action>;
-        update(id: string, body: import("./actions").UpdateActionBody): Promise<import("./actions").Action>;
+        update(id: string, body: import("./actions").UpdateActionBody): Promise<import("./actions").ActionWithSecret>;
         delete(id: string): Promise<{
             object: "action";
             id: string;
             deleted: true;
         }>;
         test(id: string, event?: import("./actions").ActionTestEvent): Promise<import("./actions").ActionTestResult>;
+        calls(id: string, query?: {
+            limit?: number;
+            status?: "ok" | "denied" | "failed" | "timeout" | "error" | "invalid_response";
+            test?: boolean;
+            starting_after?: string;
+        }): Promise<import("./actions").ActionHttpCallList>;
         getBindings(trigger: import("./actions").ActionTrigger): Promise<import("./actions").ActionBindingList>;
         setBindings(trigger: import("./actions").ActionTrigger, actionIds: string[]): Promise<import("./actions").ActionBindingList>;
     };
+    workflows: {
+        list(): Promise<import("./types").ListPage<import("./workflows").Workflow>>;
+        create(body: import("./workflows").CreateWorkflowBody, idempotencyKey?: string): Promise<import("./workflows").Workflow>;
+        get(id: string): Promise<import("./workflows").Workflow>;
+        update(id: string, body: import("./workflows").UpdateWorkflowBody): Promise<import("./workflows").Workflow>;
+        delete(id: string): Promise<{
+            object: "workflow";
+            id: string;
+            deleted: true;
+        }>;
+        dryRun(id: string, target?: {
+            user_id?: string;
+            organization_id?: string;
+        }): Promise<import("./workflows").WorkflowRun>;
+        run(id: string, target?: {
+            user_id?: string;
+            organization_id?: string;
+        }, idempotencyKey?: string): Promise<import("./workflows").WorkflowRun>;
+        runs(id: string, query?: {
+            limit?: number;
+            starting_after?: string;
+        }): Promise<import("./types").ListPage<import("./workflows").WorkflowRun> & {
+            next_cursor: string | null;
+        }>;
+    };
+    pageTemplates: {
+        list(): Promise<import("./types").ListPage<import("./page-templates").PageTemplate>>;
+        get(page: import("./page-templates").PageTemplatePage): Promise<import("./page-templates").PageTemplate>;
+        saveDraft(page: import("./page-templates").PageTemplatePage, definition: import("./page-templates").PageTemplateDefinition): Promise<import("./page-templates").PageTemplate>;
+        preview(page: import("./page-templates").PageTemplatePage): Promise<import("./page-templates").PageTemplatePreview>;
+        promote(page: import("./page-templates").PageTemplatePage): Promise<import("./page-templates").PageTemplate>;
+        discard(page: import("./page-templates").PageTemplatePage, status: "draft" | "live"): Promise<import("./page-templates").PageTemplate>;
+    };
     actionGallery: {
         list(filter?: import("./action-gallery").ActionGalleryFilter): Promise<import("./types").ListPage<import("./action-gallery").ActionGalleryEntry>>;
         get(slug: string): Promise<import("./action-gallery").ActionGalleryDetail>;
@@ -1177,6 +1803,18 @@ declare function buildNamespaces(request: RequestFn): {
             deleted: true;
         }>;
     };
+    /** MCP tool gateway: per-tool policy in front of an MCP server. */
+    mcpGateways: {
+        list(): Promise<import("./types").ListPage<import("./mcp-gateways").McpGateway>>;
+        create(body: import("./mcp-gateways").CreateMcpGatewayBody, idempotencyKey?: string): Promise<import("./mcp-gateways").McpGateway>;
+        get(id: string): Promise<import("./mcp-gateways").McpGateway>;
+        update(id: string, body: import("./mcp-gateways").UpdateMcpGatewayBody): Promise<import("./mcp-gateways").McpGateway>;
+        delete(id: string): Promise<{
+            object: "mcp_gateway";
+            id: string;
+            deleted: true;
+        }>;
+    };
     ltiPlatforms: {
         list(): Promise<import("./types").ListPage<import("./lti-platforms").LtiPlatform>>;
         get(id: string): Promise<import("./lti-platforms").LtiPlatform>;
@@ -1706,6 +2344,150 @@ declare function buildNamespaces(request: RequestFn): {
             deleted: number;
         }>;
     };
+    auditEventSchemas: {
+        list(): Promise<{
+            object: "list";
+            data: import("./audit-events").AuditEventSchema[];
+            has_more: false;
+        }>;
+        get(id: string): Promise<import("./audit-events").AuditEventSchema>;
+        register(body: import("./audit-events").RegisterAuditEventSchemaBody): Promise<import("./audit-events").AuditEventSchema>;
+        update(id: string, body: {
+            description?: string | null;
+            status?: "active" | "deprecated";
+        }): Promise<import("./audit-events").AuditEventSchema>;
+        delete(id: string): Promise<{
+            object: "audit_event_schema";
+            id: string;
+            deleted: true;
+        }>;
+        redact(eventId: string, body: {
+            fields: string[];
+            reason: string;
+        }): Promise<{
+            object: "audit_event_redaction";
+            event_id: string;
+            redacted: string[];
+            unchanged: string[];
+            reason: string;
+        }>;
+        redactions(eventId: string): Promise<{
+            object: "list";
+            data: Array<{
+                id: string;
+                event_id: string;
+                fields: string[];
+                reason: string;
+                redacted_by: string | null;
+                created_at: number;
+            }>;
+            has_more: false;
+        }>;
+    };
+    vault: {
+        create(body: import("./vault").CreateVaultObjectBody, idempotencyKey?: string): Promise<import("./vault").VaultObject>;
+        list(params?: import("./vault").ListVaultObjectsParams): Promise<import("./types").CursorPage<import("./vault").VaultObject>>;
+        read(id: string, version?: number): Promise<import("./vault").VaultObjectWithValue>;
+        metadata(id: string): Promise<import("./vault").VaultObject>;
+        versions(id: string): Promise<{
+            object: "list";
+            data: import("./vault").VaultObjectVersion[];
+        }>;
+        update(id: string, body: {
+            value: string;
+            version_check?: number;
+        }): Promise<import("./vault").VaultObject>;
+        delete(id: string): Promise<{
+            object: "vault_object.deleted";
+            id: string;
+            deleted: boolean;
+        }>;
+        keyProvider: {
+            get(): Promise<import("./vault").VaultKeyProvider>;
+            set(body: import("./vault").SetVaultKeyProviderBody): Promise<import("./vault").VaultKeyProvider>;
+            remove(): Promise<{
+                object: "vault_key_provider.deleted";
+                deleted: boolean;
+            }>;
+        };
+    };
+    serviceConnectors: {
+        catalog(): Promise<{
+            object: "list";
+            data: import("./service-connectors").ServiceConnectorKind[];
+            has_more: boolean;
+        }>;
+        list(): Promise<{
+            object: "list";
+            data: import("./service-connectors").ServiceConnector[];
+            has_more: boolean;
+        }>;
+        get(id: string): Promise<import("./service-connectors").ServiceConnector>;
+        create(body: import("./service-connectors").CreateServiceConnectorBody, idempotencyKey?: string): Promise<import("./service-connectors").ServiceConnector>;
+        update(id: string, body: import("./service-connectors").UpdateServiceConnectorBody): Promise<import("./service-connectors").ServiceConnector>;
+        delete(id: string): Promise<{
+            object: "service_connector.deleted";
+            id: string;
+            deleted: boolean;
+        }>;
+        invoke(id: string, operation: string, input?: Record<string, unknown>): Promise<{
+            object: "service_connector_result";
+            operation: string;
+            result: Record<string, unknown>;
+        }>;
+    };
+    identityVerification: {
+        settings(): Promise<import("./identity-verification").IdentityVerificationSettings>;
+        updateSettings(body: {
+            enabled: boolean;
+            connector_id?: string | null;
+            as_challenge?: boolean;
+        }): Promise<import("./identity-verification").IdentityVerificationSettings>;
+        list(params?: {
+            status?: import("./identity-verification").IdentityVerificationOutcome;
+        }): Promise<{
+            object: "list";
+            data: import("./identity-verification").IdentityVerification[];
+            has_more: boolean;
+        }>;
+        get(id: string): Promise<import("./identity-verification").IdentityVerification>;
+        decide(id: string, body: {
+            decision: "approved" | "declined";
+            reason?: string;
+        }): Promise<import("./identity-verification").IdentityVerification>;
+        forUser(userId: string): Promise<{
+            object: "list";
+            data: import("./identity-verification").IdentityVerification[];
+            has_more: boolean;
+        }>;
+        start(userId: string, body?: {
+            redirect_url?: string;
+        }): Promise<import("./identity-verification").IdentityVerification>;
+    };
+    flags: {
+        create(body: import("./flags").CreateFeatureFlagBody, idempotencyKey?: string): Promise<import("./flags").FeatureFlag>;
+        list(params?: import("./types").CursorParams): Promise<{
+            object: "list";
+            data: import("./flags").FeatureFlag[];
+            has_more: boolean;
+        }>;
+        retrieve(key: string): Promise<import("./flags").FeatureFlag>;
+        update(key: string, body: import("./flags").UpdateFeatureFlagBody): Promise<import("./flags").FeatureFlag>;
+        delete(key: string): Promise<{
+            object: "feature_flag";
+            id: string;
+            key: string;
+            deleted: boolean;
+        }>;
+        evaluate(body: import("./flags").FeatureFlagSubject & {
+            keys?: string[];
+        }): Promise<import("./flags").FeatureFlagEvaluation>;
+        get<T extends import("./flags").FeatureFlagValue>(key: string, subject: import("./flags").FeatureFlagSubject, fallback: T): Promise<T>;
+        isEnabled(key: string, subject?: import("./flags").FeatureFlagSubject): Promise<boolean>;
+        invalidate(): void;
+        assignOrganizationEntitlements(orgId: string, body: import("./flags").AssignEntitlementsBody): Promise<import("./flags").AssignedEntitlements>;
+        assignUserEntitlements(userId: string, body: import("./flags").AssignEntitlementsBody): Promise<import("./flags").AssignedEntitlements>;
+    };
     whoami: () => Promise<import("./credentials").Whoami>;
     secretKeys: {
         create(body: import("./credentials").CreateSecretKeyBody): Promise<import("./credentials").SecretKeyWithSecret>;
@@ -1719,6 +2501,7 @@ declare function buildNamespaces(request: RequestFn): {
             expires_at?: number | string | null;
             allowed_ips?: string[];
             allowed_origins?: string[];
+            organization_ids?: string[];
             metadata?: Record<string, string | number | boolean> | null;
         }): Promise<import("./credentials").SecretKey>;
         rotate(id: string, body?: {
@@ -1836,6 +2619,141 @@ declare function buildNamespaces(request: RequestFn): {
             days?: number;
         }): Promise<import("./activity").UsageReport>;
     };
+    analytics: {
+        funnel: (params?: import("./analytics-reports").AnalyticsParams & {
+            kind?: "sign_in" | "sign_up";
+        }) => Promise<import("./analytics-reports").AnalyticsReport<import("./analytics-reports").FunnelRow>>;
+        journeyFunnel: (params: Omit<import("./analytics-reports").AnalyticsParams, "organization_id"> & {
+            journey_id: string;
+        }) => Promise<import("./analytics-reports").AnalyticsReport<import("./analytics-reports").JourneyFunnelRow>>;
+        failures: (params?: Omit<import("./analytics-reports").AnalyticsParams, "organization_id">) => Promise<import("./analytics-reports").AnalyticsReport<import("./analytics-reports").FailureRow>>;
+        breakdown: (params?: import("./analytics-reports").AnalyticsParams & {
+            dimension?: "method" | "device" | "browser" | "os" | "country";
+        }) => Promise<import("./analytics-reports").AnalyticsReport<import("./analytics-reports").BreakdownRow>>;
+        activeUsers: (params?: import("./analytics-reports").AnalyticsParams) => Promise<import("./analytics-reports").AnalyticsReport<import("./analytics-reports").ActiveUsersRow>>;
+        passkeyAdoption: (params?: import("./analytics-reports").AnalyticsParams) => Promise<import("./analytics-reports").AnalyticsReport<import("./analytics-reports").PasskeyAdoptionRow>>;
+        apiUsage: (params?: {
+            subject_type?: import("./analytics-reports").UsageSubjectType;
+            subject_id?: string;
+            window_minutes?: number;
+        }) => Promise<{
+            object: "api_usage";
+            window_minutes: number;
+            baseline_hours: number;
+            generated_at: number;
+            data: import("./analytics-reports").ApiUsageSubject[];
+        }>;
+        reports: {
+            inactiveUsers: (params?: import("./analytics-reports").AnalyticsParams & {
+                inactive_days?: number;
+                limit?: number;
+                starting_after?: string;
+            }) => Promise<import("./analytics-reports").AnalyticsReport<import("./analytics-reports").InactiveUserRow>>;
+            mfaCoverage: (params?: import("./analytics-reports").AnalyticsParams) => Promise<import("./analytics-reports").AnalyticsReport<import("./analytics-reports").MfaCoverageRow>>;
+            accessByApp: (params?: import("./analytics-reports").AnalyticsParams) => Promise<import("./analytics-reports").AnalyticsReport<import("./analytics-reports").AccessByAppRow>>;
+        };
+        exportCsv: (report: "funnel" | "failures" | "breakdown" | "active_users" | "passkey_adoption" | "reports/inactive_users" | "reports/mfa_coverage" | "reports/access_by_app", params?: object) => Promise<string>;
+        alertRules: {
+            list(): Promise<{
+                object: "list";
+                data: import("./analytics-reports").AnalyticsAlertRule[];
+                has_more: boolean;
+            }>;
+            get(id: string): Promise<import("./analytics-reports").AnalyticsAlertRule>;
+            create(body: import("./analytics-reports").AnalyticsAlertRuleInput, idempotencyKey?: string): Promise<import("./analytics-reports").AnalyticsAlertRule & {
+                webhook_secret?: string;
+            }>;
+            update(id: string, body: Partial<import("./analytics-reports").AnalyticsAlertRuleInput>): Promise<import("./analytics-reports").AnalyticsAlertRule & {
+                webhook_secret?: string;
+            }>;
+            delete(id: string): Promise<import("./types").DeletedObject>;
+            test(id: string, body?: {
+                notify?: boolean;
+            }): Promise<{
+                object: "analytics_alert_test";
+                value: number | null;
+                sample: number;
+                subject: import("./analytics-reports").ApiUsageSubject | null;
+                notified: boolean;
+                error: string | null;
+            }>;
+        };
+    };
+    appCatalog: {
+        presets(): Promise<{
+            object: "list";
+            data: import("./app-catalog").AppPreset[];
+        }>;
+        installed(): Promise<{
+            object: "list";
+            data: import("./app-catalog").InstalledApp[];
+        }>;
+        install(presetId: string, body?: import("./app-catalog").InstallAppBody, idempotencyKey?: string): Promise<import("./app-catalog").InstalledApp & {
+            client_secret?: string;
+            redirect_uri?: string;
+            issuer?: string;
+        }>;
+        update(id: string, body: Pick<import("./app-catalog").InstallAppBody, "name" | "allowed_email_domains" | "assignment">): Promise<import("./app-catalog").InstalledApp>;
+        uninstall(id: string): Promise<{
+            object: "installed_app";
+            id: string;
+            deleted: true;
+        }>;
+    };
+    journeys: {
+        list(): Promise<{
+            object: "list";
+            data: import("./journeys").SignInJourney[];
+            has_more: boolean;
+        }>;
+        get(id: string): Promise<import("./journeys").SignInJourney>;
+        create(body: import("./journeys").JourneyBody & {
+            name: string;
+            definition: import("./journeys").JourneyDefinition;
+        }, idempotencyKey?: string): Promise<import("./journeys").SignInJourney>;
+        update(id: string, body: import("./journeys").JourneyBody, idempotencyKey?: string): Promise<import("./journeys").SignInJourney>;
+        delete(id: string): Promise<{
+            object: "sign_in_journey";
+            id: string;
+            deleted: true;
+        }>;
+        versions(id: string): Promise<{
+            object: "list";
+            data: Array<{
+                version: number;
+                definition: import("./journeys").JourneyDefinition;
+                created_by: string | null;
+                created_at: number;
+            }>;
+        }>;
+        activate(id: string, version: number): Promise<import("./journeys").SignInJourney>;
+        simulate(id: string, body: {
+            user_id: string;
+            method?: string;
+            mfa_verified?: boolean;
+            ip?: string;
+            application_id?: string;
+            version?: number;
+        }): Promise<import("./journeys").JourneySimulation>;
+    };
+    marketing: {
+        getSettings(): Promise<import("./marketing").MarketingSettings>;
+        updateSettings(body: import("./marketing").MarketingSettingsInput): Promise<import("./marketing").MarketingSettings>;
+        listLeads(params?: {
+            limit?: number;
+            starting_after?: string;
+            form?: string;
+        }): Promise<{
+            object: "list";
+            data: import("./marketing").MarketingLead[];
+            has_more: boolean;
+            next_cursor: string | null;
+        }>;
+        exportLeadsCsv(params?: {
+            form?: string;
+        }): Promise<string>;
+        deleteLead(id: string): Promise<import("./types").DeletedObject>;
+    };
     configChangelog: {
         list(params?: import("./activity").ListConfigChangelogParams): Promise<{
             object: "config_changelog";
@@ -1959,11 +2877,16 @@ export { AtlasApiError, type AtlasErrorItem } from './error';
 export { paginate, collect } from './paginate';
 export * from './types';
 export * from './compliance';
+export * from './vault';
+export * from './service-connectors';
+export * from './identity-verification';
+export * from './flags';
 export * from './users';
 export * from './sessions';
 export * from './organizations';
 export * from './roles';
 export * from './app-roles';
+export * from './groups';
 export * from './oauth-clients';
 export * from './resource-servers';
 export * from './sso-connections';
@@ -1972,6 +2895,7 @@ export * from './domains';
 export * from './waitlist';
 export * from './restrictions';
 export * from './attack-protection';
+export * from './mfa-factors';
 export * from './actor-tokens';
 export * from './invitations';
 export * from './webhooks';
@@ -1986,8 +2910,15 @@ export * from './scim-provisioning';
 export * from './fga';
 export * from './rate-limit';
 export * from './risk-based-mfa';
+export * from './ssf';
 export * from './bot-signals';
 export * from './network-acls';
+export * from './network-zones';
+export * from './access-policies';
+export * from './abac';
+export * from './resources';
+export * from './org-role-grants';
+export * from './devices';
 export * from './managed-waf';
 export * from './log-streams';
 export * from './branding';
@@ -1995,6 +2926,8 @@ export * from './email-templates';
 export * from './sms-templates';
 export * from './localizations';
 export * from './actions';
+export * from './page-templates';
+export * from './workflows';
 export * from './action-gallery';
 export * from './billing-plans';
 export * from './messaging';
@@ -2004,6 +2937,7 @@ export * from './migrations';
 export * from './data-subject-requests';
 export * from './privacy';
 export * from './radius-clients';
+export * from './mcp-gateways';
 export * from './lti-platforms';
 export * from './instance';
 export * from './integrations';
@@ -2021,10 +2955,17 @@ export * from './organization-settings-schema';
 export * from './email-addresses';
 export * from './openfga';
 export * from './connectors';
+export * from './passkey-api';
+export * from './delegated-ui-proxy';
+export * from './vc';
 export * from './custom-oauth-providers';
 export * from './notifications';
 export * from './audit-events';
 export * from './activity';
+export * from './analytics-reports';
+export * from './app-catalog';
+export * from './journeys';
+export * from './marketing';
 export * from './pca';
 export * from './mcp';
 export * from './legacy-auth';