@atlasauth/backend 0.24.0 → 0.26.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,84 @@ 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[];
+                revocation_policy?: import("./vc").VcRevocationPolicy;
+                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 +743,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 +950,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>;
@@ -712,6 +1084,10 @@ declare function buildNamespaces(request: RequestFn): {
         syncGroup(id: string, organizationId: string): Promise<import("./scim-provisioning").ScimProvisioningGroupSyncResult>;
     };
     fga: {
+        settings: {
+            get(): Promise<import("./fga").FgaSettings>;
+            update(body: import("./fga").UpdateFgaSettingsBody): Promise<import("./fga").FgaSettings>;
+        };
         stores: {
             list(): Promise<import("./types").ListPage<import("./fga").FgaStore>>;
             create(body: {
@@ -736,6 +1112,7 @@ declare function buildNamespaces(request: RequestFn): {
             object: "fga.write_result";
             writes: number;
             deletes: number;
+            consistency_token: string;
         }>;
         read(storeId: string, body: {
             user?: string;
@@ -746,16 +1123,23 @@ declare function buildNamespaces(request: RequestFn): {
             object: "fga.check";
             allowed: boolean;
             authorization_model_id: string;
+            consistency_token: string;
         }>;
         batchCheck(storeId: string, body: {
             checks: import("./fga").FgaBatchCheckItem[];
             authorization_model_id?: string;
-        }): Promise<import("./fga").FgaBatchCheckResult>;
+        } & import("./fga").FgaConsistencyOptions): Promise<import("./fga").FgaBatchCheckResult>;
         listObjects(storeId: string, body: import("./fga").FgaListObjectsBody): Promise<{
             object: "fga.list_objects";
             objects: string[];
+            has_more: boolean;
+            next_cursor: string | null;
             authorization_model_id: string;
+            consistency_token: string;
         }>;
+        listUsers(storeId: string, body: import("./fga").FgaListUsersBody): Promise<import("./fga").FgaListUsersResult>;
+        listAllUsers(storeId: string, body: import("./fga").FgaListUsersBody): Promise<import("./fga").FgaListUsersResult>;
+        readChanges(storeId: string, params?: import("./fga").FgaReadChangesParams): Promise<import("./fga").FgaChangesPage>;
         expand(storeId: string, body: {
             object: string;
             relation: string;
@@ -773,6 +1157,7 @@ declare function buildNamespaces(request: RequestFn): {
                 object: "fga.write_result";
                 writes: number;
                 deletes: number;
+                consistency_token: string;
             }>;
             read: (body: {
                 user?: string;
@@ -783,16 +1168,23 @@ declare function buildNamespaces(request: RequestFn): {
                 object: "fga.check";
                 allowed: boolean;
                 authorization_model_id: string;
+                consistency_token: string;
             }>;
             batchCheck: (body: {
                 checks: import("./fga").FgaBatchCheckItem[];
                 authorization_model_id?: string;
-            }) => Promise<import("./fga").FgaBatchCheckResult>;
+            } & import("./fga").FgaConsistencyOptions) => Promise<import("./fga").FgaBatchCheckResult>;
             listObjects: (body: import("./fga").FgaListObjectsBody) => Promise<{
                 object: "fga.list_objects";
                 objects: string[];
+                has_more: boolean;
+                next_cursor: string | null;
                 authorization_model_id: string;
+                consistency_token: string;
             }>;
+            listUsers: (body: import("./fga").FgaListUsersBody) => Promise<import("./fga").FgaListUsersResult>;
+            listAllUsers: (body: import("./fga").FgaListUsersBody) => Promise<import("./fga").FgaListUsersResult>;
+            readChanges: (params?: import("./fga").FgaReadChangesParams) => Promise<import("./fga").FgaChangesPage>;
             expand: (body: {
                 object: string;
                 relation: string;
@@ -816,6 +1208,100 @@ 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>;
+        };
+    };
+    managedGrants: {
+        list(query?: import("./managed-grants").ListManagedGrantsQuery): Promise<{
+            object: "list";
+            data: import("./managed-grants").ManagedGrant[];
+        }>;
+        get(id: string): Promise<import("./managed-grants").ManagedGrant>;
+        narrow(id: string, body: {
+            scopes?: string[];
+            authorization_details?: Record<string, unknown>[];
+        }): Promise<import("./managed-grants").ManagedGrant>;
+        revoke(id: string): Promise<{
+            object: "managed_grant";
+            id: string;
+            deleted: true;
+            tokens_ended: number;
+        }>;
+    };
+    leastPrivilege: {
+        report(query?: import("./least-privilege").LeastPrivilegeReportQuery): Promise<import("./least-privilege").LeastPrivilegeReport>;
+        get(type: import("./least-privilege").LeastPrivilegeSubjectType, id: string, query?: {
+            days?: number;
+        }): Promise<import("./least-privilege").LeastPrivilegeSubject>;
+        exportCsv(query?: import("./least-privilege").LeastPrivilegeReportQuery): Promise<string>;
+        apply(body: import("./least-privilege").ApplyLeastPrivilegeBody, options?: {
+            dryRun?: boolean;
+        }): Promise<{
+            object: "least_privilege_change";
+            subject_type: import("./least-privilege").LeastPrivilegeSubjectType;
+            subject_id: string;
+            applied: true;
+            summary: string;
+            changes: import("./least-privilege").LeastPrivilegeChange[];
+        }>;
     };
     botSignals: {
         list(query?: import("./bot-signals").BotExportParams): Promise<import("./bot-signals").BotExportPage<import("./bot-signals").BotSignal>>;
@@ -833,6 +1319,264 @@ 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>;
+        partialEvaluate(body: import("./abac").AbacPartialBody): Promise<import("./abac").AbacResidual>;
+        accessibleResources(body: import("./abac").AbacAccessibleBody): Promise<import("./abac").AbacAccessibleList>;
+        templates: {
+            list(): Promise<import("./types").ListPage<import("./abac").AbacPolicyTemplate>>;
+            get(id: string): Promise<import("./abac").AbacPolicyTemplate>;
+            create(body: import("./abac").CreateAbacTemplateBody, idempotencyKey?: string): Promise<import("./abac").AbacPolicyTemplate>;
+            update(id: string, body: Partial<import("./abac").CreateAbacTemplateBody>): Promise<import("./abac").AbacPolicyTemplate>;
+            delete(id: string, opts?: {
+                force?: boolean;
+            }): Promise<{
+                object: "abac_policy_template";
+                id: string;
+                deleted: true;
+                links_deleted: number;
+            }>;
+        };
+        links: {
+            list(query?: {
+                template_id?: string;
+            }): Promise<import("./types").ListPage<import("./abac").AbacPolicyLink>>;
+            get(id: string): Promise<import("./abac").AbacPolicyLink>;
+            create(body: import("./abac").CreateAbacLinkBody, idempotencyKey?: string): Promise<import("./abac").AbacPolicyLink>;
+            update(id: string, body: Partial<Omit<import("./abac").CreateAbacLinkBody, "template_id">>): Promise<import("./abac").AbacPolicyLink>;
+            delete(id: string): Promise<{
+                object: "abac_policy_link";
+                id: string;
+                deleted: true;
+            }>;
+        };
+        schema: {
+            get(): Promise<import("./abac").AbacSchemaState>;
+            set(schema: import("./abac").AbacSchemaDocument): Promise<import("./abac").AbacSchemaState>;
+            delete(): Promise<{
+                object: "abac_schema";
+                deleted: true;
+            }>;
+            validate(body: {
+                source: string;
+                schema?: import("./abac").AbacSchemaDocument;
+                template?: boolean;
+            }): Promise<import("./abac").AbacValidation>;
+        };
+        diff(id: string, opts?: import("./abac").AbacDiffOptions): Promise<import("./abac").AbacPolicyDiff>;
+        diffSources(body: {
+            before: string;
+            after: string;
+            semantic?: boolean;
+            max_requests?: number;
+            max_changes?: number;
+        }): Promise<import("./abac").AbacPolicyDiff>;
+        authzenSearchSubject(body: import("./abac").AuthzenSearchRequest): Promise<{
+            results: Array<{
+                type: string;
+                id: string;
+            }>;
+            page: import("./abac").AuthzenSearchPage;
+        }>;
+        authzenSearchResource(body: import("./abac").AuthzenSearchRequest): Promise<{
+            results: Array<{
+                type: string;
+                id: string;
+            }>;
+            page: import("./abac").AuthzenSearchPage;
+        }>;
+        authzenSearchAction(body: import("./abac").AuthzenSearchRequest): Promise<{
+            results: Array<{
+                name: string;
+            }>;
+            page: import("./abac").AuthzenSearchPage;
+        }>;
+        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;
+            }>;
+        }>;
+    };
+    authzDecisions: {
+        list(params?: import("./authz-decisions").ListAuthzDecisionsParams): Promise<import("./authz-decisions").AuthzDecisionPage>;
+        iterate(params?: Omit<import("./authz-decisions").ListAuthzDecisionsParams, "starting_after">): AsyncGenerator<import("./authz-decisions").AuthzDecision>;
+        get(id: string): Promise<import("./authz-decisions").AuthzDecision>;
+        stats(params?: {
+            since?: string | number;
+            until?: string | number;
+        }): Promise<import("./authz-decisions").AuthzDecisionStats>;
+        settings: {
+            get(): Promise<import("./authz-decisions").AuthzDecisionSettings>;
+            update(body: import("./authz-decisions").UpdateAuthzDecisionSettingsBody): Promise<import("./authz-decisions").AuthzDecisionSettings>;
+        };
+    };
+    policyBundles: {
+        list(): Promise<{
+            object: "list";
+            data: import("./policy-bundles").PolicyBundle[];
+            has_more: boolean;
+        }>;
+        current(): Promise<{
+            object: "policy_bundle_revision";
+            revision: string;
+        }>;
+        export(): Promise<import("./policy-bundles").PolicyBundle>;
+        get(revision: string): Promise<import("./policy-bundles").PolicyBundle>;
+        verify(body: import("./policy-bundles").PolicyBundleUpload): Promise<import("./policy-bundles").PolicyBundleVerification>;
+        import(body: import("./policy-bundles").PolicyBundleUpload & {
+            dry_run?: boolean;
+            prune?: boolean;
+        }): Promise<import("./policy-bundles").PolicyBundleImport>;
+    };
+    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;
+            starting_after?: string;
+        }): 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 +1666,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 +1960,33 @@ 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;
+        }>;
+        budgets: {
+            list(gatewayId: string): Promise<import("./types").ListPage<import("./mcp-gateways").McpBudget>>;
+            create(gatewayId: string, body: import("./mcp-gateways").CreateMcpBudgetBody): Promise<import("./mcp-gateways").McpBudget>;
+            get(gatewayId: string, budgetId: string): Promise<import("./mcp-gateways").McpBudget>;
+            update(gatewayId: string, budgetId: string, body: Partial<import("./mcp-gateways").CreateMcpBudgetBody>): Promise<import("./mcp-gateways").McpBudget>;
+            delete(gatewayId: string, budgetId: string): Promise<{
+                object: "mcp_budget";
+                id: string;
+                deleted: true;
+            }>;
+            usage(gatewayId: string, budgetId: string, query?: {
+                agent_id?: string;
+                session_id?: string;
+            }): Promise<import("./mcp-gateways").McpBudgetUsage>;
+        };
+    };
     ltiPlatforms: {
         list(): Promise<import("./types").ListPage<import("./lti-platforms").LtiPlatform>>;
         get(id: string): Promise<import("./lti-platforms").LtiPlatform>;
@@ -1594,6 +2404,12 @@ declare function buildNamespaces(request: RequestFn): {
         listObjects(store: string, body: import("./openfga").OpenFgaListObjectsBody): Promise<{
             objects: string[];
         }>;
+        listUsers(store: string, body: import("./openfga").OpenFgaListUsersBody): Promise<import("./openfga").OpenFgaListUsersResult>;
+        listAllUsers(store: string, body: import("./openfga").OpenFgaListUsersBody): Promise<import("./openfga").OpenFgaListUsersResult>;
+        readChanges(store: string, params?: import("./openfga").OpenFgaReadChangesParams): Promise<{
+            changes: import("./openfga").OpenFgaTupleChange[];
+            continuation_token: string;
+        }>;
         read(store: string, body?: import("./openfga").OpenFgaReadBody): Promise<{
             tuples: import("./openfga").OpenFgaTuple[];
             continuation_token: string;
@@ -1627,6 +2443,65 @@ declare function buildNamespaces(request: RequestFn): {
             data: import("./connectors").ConnectorDirectoryEntry[];
         }>;
     };
+    connections: {
+        create(body: import("./connections").CreateConnectionBody, idempotencyKey?: string): Promise<import("./connections").Connection>;
+        list(params?: import("./connections").ListConnectionsParams): Promise<import("./types").ListPage<import("./connections").Connection>>;
+        get(id: string): Promise<import("./connections").Connection>;
+        update(id: string, body: import("./connections").UpdateConnectionBody): Promise<import("./connections").Connection>;
+        delete<R extends boolean = false>(id: string, options?: {
+            revoke?: R;
+        }): Promise<R extends true ? import("./connections").ConnectionDeletion : void>;
+        connect(id: string, body: import("./connections").ConnectConnectionBody): Promise<import("./connections").ConnectionAuthorization>;
+        revoke(id: string): Promise<import("./connections").ConnectionRevoked>;
+        token(id: string, options?: import("./connections").TokenReadOptions): Promise<import("./connections").ConnectionToken>;
+        refreshToken(id: string, options?: {
+            staleAccessToken?: string;
+            reason?: "provider_401" | "expired" | "manual";
+        }): Promise<import("./connections").ConnectionToken>;
+        tokens(ids: string[], options?: {
+            minTtlSeconds?: number;
+        }): Promise<{
+            object: "list";
+            data: import("./connections").ConnectionTokenBatchItem[];
+            has_more: false;
+        }>;
+        importConnections(body: import("./connections").ImportConnectionsBody, idempotencyKey?: string): Promise<import("./connections").ImportConnectionsResult>;
+        exportConnections(body?: import("./connections").ExportConnectionsBody): Promise<import("./connections").ExportConnectionsResult>;
+        setCredentials(id: string, body: import("./connections").SetConnectionCredentialsBody): Promise<import("./connections").Connection>;
+        rotateCredentials(id: string, body: import("./connections").RotateConnectionCredentialsBody): Promise<import("./connections").Connection>;
+        secretVersions(id: string): Promise<import("./connections").ConnectionSecretVersions>;
+        secret(id: string, options?: {
+            version?: "current" | "previous" | number;
+            organizationId?: string;
+        }): Promise<import("./connections").ConnectionSecret>;
+        oauth1Sign(id: string, body: {
+            method?: string;
+            url: string;
+            body?: string;
+            content_type?: string;
+        }): Promise<import("./connections").ConnectionSignature>;
+        webhooks: {
+            verify(id: string, body: import("./connections").VerifyConnectionWebhookBody): Promise<import("./connections").ConnectionWebhookVerification>;
+            createEndpoint(id: string, body: import("./connections").CreateConnectionWebhookEndpointBody): Promise<import("./connections").ConnectionWebhookEndpoint>;
+            listEndpoints(id: string): Promise<import("./types").ListPage<import("./connections").ConnectionWebhookEndpoint>>;
+            updateEndpoint(id: string, endpointId: string, body: {
+                forward_url?: string;
+                enabled?: boolean;
+                signing_secret?: string;
+            }): Promise<import("./connections").ConnectionWebhookEndpoint>;
+            deleteEndpoint(id: string, endpointId: string): Promise<void>;
+        };
+        oauthClients: {
+            set(body: import("./connections").SetConnectionOAuthClientBody): Promise<import("./connections").ConnectionOAuthClient>;
+            list(params?: {
+                owner_type?: import("./connections").ConnectionOwnerType;
+                owner_id?: string;
+                provider?: string;
+            }): Promise<import("./types").ListPage<import("./connections").ConnectionOAuthClient>>;
+            get(id: string): Promise<import("./connections").ConnectionOAuthClient>;
+            delete(id: string): Promise<void>;
+        };
+    };
     customOAuthProviders: {
         list(): Promise<import("./types").ListPage<import("./custom-oauth-providers").CustomOAuthProvider>>;
         get(id: string): Promise<import("./custom-oauth-providers").CustomOAuthProvider>;
@@ -1706,6 +2581,394 @@ 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>;
+        }>;
+    };
+    desktopMfa: {
+        getPolicy(): Promise<import("./desktop-mfa").DesktopMfaPolicy>;
+        updatePolicy(body: import("./desktop-mfa").UpdateDesktopMfaPolicyBody): Promise<import("./desktop-mfa").DesktopMfaPolicy>;
+        createEnrolmentCode(body: {
+            user_id: string;
+            expires_in_minutes?: number;
+        }): Promise<import("./desktop-mfa").DesktopEnrolmentCode>;
+        listDevices(query?: {
+            user_id?: string;
+        }): Promise<{
+            object: "list";
+            data: import("./desktop-mfa").DesktopDevice[];
+            has_more: boolean;
+        }>;
+        getDevice(id: string): Promise<import("./desktop-mfa").DesktopDeviceDetail>;
+        listDevicePasskeys(id: string): Promise<{
+            object: "list";
+            data: import("./desktop-mfa").DesktopPasskey[];
+            has_more: boolean;
+        }>;
+        deleteDevicePasskey(id: string, passkeyId: string): Promise<{
+            object: "desktop_passkey";
+            id: string;
+            deleted: boolean;
+        }>;
+        revokeDevice(id: string): Promise<import("./desktop-mfa").DesktopDevice>;
+        revokeOfflineCache(id: string): Promise<import("./desktop-mfa").DesktopDevice>;
+        deleteDevice(id: string): Promise<{
+            object: "desktop_device";
+            id: string;
+            deleted: boolean;
+        }>;
+    };
+    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>;
+    };
+    iga: {
+        entitlements: {
+            list: (params?: {
+                kind?: import("./iga").IgaKind;
+            }) => Promise<{
+                object: "list";
+                data: import("./iga").IgaEntitlement[];
+                has_more: boolean;
+            }>;
+            get: (idOrKey: string) => Promise<import("./iga").IgaEntitlement>;
+            create: (body: import("./iga").IgaEntitlementInput) => Promise<import("./iga").IgaEntitlement>;
+            update: (idOrKey: string, body: Partial<Omit<import("./iga").IgaEntitlementInput, "key" | "kind">>) => Promise<import("./iga").IgaEntitlement>;
+            delete: (idOrKey: string) => Promise<{
+                object: "iga_entitlement";
+                id: string;
+                deleted: true;
+            }>;
+        };
+        requests: {
+            list: (params?: {
+                status?: import("./iga").IgaRequestStatus;
+                user_id?: string;
+                requester_user_id?: string;
+                entitlement?: string;
+                limit?: number;
+            }) => Promise<{
+                object: "list";
+                data: import("./iga").IgaRequest[];
+                has_more: boolean;
+            }>;
+            get: (id: string) => Promise<import("./iga").IgaRequest>;
+            create: (body: {
+                entitlement: string;
+                user_id: string;
+                requester_user_id?: string;
+                justification?: string;
+                duration_seconds?: number;
+            }) => Promise<import("./iga").IgaRequest>;
+            decide: (id: string, body: {
+                decision: "approve" | "deny";
+                comment?: string;
+                approver_user_id?: string;
+            }) => Promise<import("./iga").IgaRequest>;
+            cancel: (id: string) => Promise<import("./iga").IgaRequest>;
+            inbox: (approverUserId: string) => Promise<{
+                object: "list";
+                data: import("./iga").IgaRequest[];
+                has_more: boolean;
+            }>;
+        };
+        grants: {
+            list: (params?: {
+                user_id?: string;
+                entitlement?: string;
+                status?: "active" | "revoked" | "expired";
+                limit?: number;
+            }) => Promise<{
+                object: "list";
+                data: import("./iga").IgaGrant[];
+                has_more: boolean;
+            }>;
+            create: (body: {
+                entitlement: string;
+                user_id: string;
+                expires_at?: number;
+                override_reason?: string;
+            }) => Promise<import("./iga").IgaGrant>;
+            revoke: (id: string, body?: {
+                reason?: string;
+            }) => Promise<import("./iga").IgaGrant>;
+        };
+        delegations: {
+            list: (params?: {
+                delegator_user_id?: string;
+            }) => Promise<{
+                object: "list";
+                data: import("./iga").IgaDelegation[];
+                has_more: boolean;
+            }>;
+            create: (body: {
+                delegator_user_id: string;
+                delegate_user_id: string;
+                ends_at: number;
+                starts_at?: number;
+            }) => Promise<import("./iga").IgaDelegation>;
+            delete: (id: string) => Promise<{
+                object: "iga_delegation";
+                id: string;
+                deleted: true;
+            }>;
+        };
+        sod: {
+            listRules: () => Promise<{
+                object: "list";
+                data: import("./iga").IgaSodRule[];
+                has_more: boolean;
+            }>;
+            createRule: (body: {
+                name: string;
+                entitlement_a: string;
+                entitlement_b: string;
+                mode?: "block" | "require_approval";
+                approver?: import("./iga").IgaApprovalStep;
+                description?: string;
+                enabled? /** The data-rights executor protocol and the instance's orchestrator. */: boolean;
+            }) => Promise<import("./iga").IgaSodRule>;
+            updateRule: (id: string, body: {
+                name?: string;
+                description?: string;
+                mode?: "block" | "require_approval";
+                approver?: import("./iga").IgaApprovalStep;
+                enabled?: boolean;
+            }) => Promise<import("./iga").IgaSodRule>;
+            deleteRule: (id: string) => Promise<{
+                object: "iga_sod_rule";
+                id: string;
+                deleted: true;
+            }>;
+            violations: (params?: {
+                status?: "open" | "accepted" | "resolved";
+            }) => Promise<{
+                object: "list";
+                data: import("./iga").IgaSodViolation[];
+                has_more: boolean;
+            }>;
+            scan: () => Promise<{
+                object: "iga_sod_scan";
+                found: number;
+                resolved: number;
+            }>;
+        };
+        lifecycle: {
+            listBirthrightRules: () => Promise<{
+                object: "list";
+                data: import("./iga").IgaBirthrightRule[];
+                has_more: boolean;
+            }>;
+            createBirthrightRule: (body: {
+                name: string;
+                match: import("./iga").IgaBirthrightMatch;
+                entitlement_ids: string[];
+                revoke_on_unmatch?: boolean;
+                enabled?: boolean;
+            }) => Promise<import("./iga").IgaBirthrightRule>;
+            updateBirthrightRule: (id: string, body: Partial<{
+                name: string;
+                match: import("./iga").IgaBirthrightMatch;
+                entitlement_ids: string[];
+                revoke_on_unmatch: boolean;
+                enabled: boolean;
+            }>) => Promise<import("./iga").IgaBirthrightRule>;
+            deleteBirthrightRule: (id: string) => Promise<{
+                object: "iga_birthright_rule";
+                id: string;
+                deleted: true;
+            }>;
+            reconcile: (userId: string) => Promise<{
+                object: "iga_jml";
+                user_id: string;
+                granted: string[];
+                revoked: string[];
+            }>;
+            offboard: (userId: string, body?: {
+                close_account?: boolean;
+                grace_seconds?: number;
+                reason?: string;
+            }) => Promise<import("./iga").IgaOffboarding>;
+            settings: () => Promise<import("./iga").IgaSettings>;
+            updateSettings: (body: Partial<Omit<import("./iga").IgaSettings, "object">>) => Promise<import("./iga").IgaSettings>;
+        };
+        campaigns: {
+            list: (params?: {
+                status?: import("./iga").IgaCampaign["status"];
+            }) => Promise<{
+                object: "list";
+                data: import("./iga").IgaCampaign[];
+                has_more: boolean;
+            }>;
+            get: (id: string) => Promise<import("./iga").IgaCampaign & {
+                progress: import("./iga").IgaCampaignProgress;
+            }>;
+            create: (body: import("./iga").IgaCampaignInput) => Promise<import("./iga").IgaCampaign>;
+            delete: (id: string) => Promise<{
+                object: "iga_campaign";
+                id: string;
+                deleted: true;
+            }>;
+            launch: (id: string) => Promise<import("./iga").IgaCampaign>;
+            close: (id: string) => Promise<import("./iga").IgaCampaign>;
+            items: (id: string, params?: {
+                decision?: import("./iga").IgaCampaignItem["decision"];
+                reviewer_user_id?: string;
+            }) => Promise<{
+                object: "list";
+                data: import("./iga").IgaCampaignItem[];
+                has_more: boolean;
+            }>;
+            progress: (id: string) => Promise<import("./iga").IgaCampaignProgress>;
+            evidence: (id: string, params?: {
+                masked_emails?: boolean;
+            }) => Promise<import("./iga").IgaEvidence>;
+            evidenceCsv: (id: string, params?: {
+                masked_emails?: boolean;
+            }) => Promise<string>;
+            decide: (itemId: string, body: {
+                decision: "certify" | "revoke";
+                comment?: string;
+                reviewer_user_id?: string;
+            }) => Promise<import("./iga").IgaCampaignItem>;
+        };
+    };
+    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 +2982,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 +3100,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 +3358,18 @@ 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 './desktop-mfa';
+export * from './identity-verification';
+export * from './iga';
+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 +3378,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 +3393,19 @@ export * from './scim-provisioning';
 export * from './fga';
 export * from './rate-limit';
 export * from './risk-based-mfa';
+export * from './ssf';
+export * from './managed-grants';
+export * from './least-privilege';
 export * from './bot-signals';
 export * from './network-acls';
+export * from './network-zones';
+export * from './access-policies';
+export * from './abac';
+export * from './authz-decisions';
+export * from './policy-bundles';
+export * from './resources';
+export * from './org-role-grants';
+export * from './devices';
 export * from './managed-waf';
 export * from './log-streams';
 export * from './branding';
@@ -1995,6 +3413,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 +3424,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 +3442,18 @@ export * from './organization-settings-schema';
 export * from './email-addresses';
 export * from './openfga';
 export * from './connectors';
+export * from './connections';
+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';