@atlasauth/backend 0.25.0 → 0.26.0

package/dist/client/index.d.ts

@@ -617,6 +617,7 @@ declare function buildNamespaces(request: RequestFn): {
                 vct: string;
                 format?: import("./vc").VcFormat;
                 iaca_roots?: string[];
+                revocation_policy?: import("./vc").VcRevocationPolicy;
                 claims?: string[];
                 trusted_issuers?: Array<{
                     issuer: string;
@@ -1083,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: {
@@ -1107,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;
@@ -1117,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;
@@ -1144,6 +1157,7 @@ declare function buildNamespaces(request: RequestFn): {
                 object: "fga.write_result";
                 writes: number;
                 deletes: number;
+                consistency_token: string;
             }>;
             read: (body: {
                 user?: string;
@@ -1154,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;
@@ -1248,6 +1269,40 @@ declare function buildNamespaces(request: RequestFn): {
             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>>;
         listLabels(query?: import("./bot-signals").BotExportParams): Promise<import("./bot-signals").BotExportPage<import("./bot-signals").BotLabel>>;
@@ -1305,6 +1360,76 @@ declare function buildNamespaces(request: RequestFn): {
             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;
@@ -1321,6 +1446,37 @@ declare function buildNamespaces(request: RequestFn): {
             }>;
         }>;
     };
+    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>>;
@@ -1373,6 +1529,7 @@ declare function buildNamespaces(request: RequestFn): {
             type?: string;
             groups?: string[];
             limit?: number;
+            starting_after?: string;
         }): Promise<import("./types").ListPage<import("./resources").Resource>>;
     };
     orgRoleGrants: {
@@ -1814,6 +1971,21 @@ declare function buildNamespaces(request: RequestFn): {
             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>>;
@@ -2232,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;
@@ -2265,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>;
@@ -2436,6 +2673,39 @@ declare function buildNamespaces(request: RequestFn): {
             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: {
@@ -2464,6 +2734,217 @@ declare function buildNamespaces(request: RequestFn): {
             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<{
@@ -2879,7 +3360,9 @@ 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';
@@ -2911,11 +3394,15 @@ 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';
@@ -2955,6 +3442,7 @@ 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';