okta-mcp-server/dist/lib/okta-client.d.ts

Model Context Protocol (MCP) server for Okta API operations with support for bulk operations and caching

import { OktaUser, OktaGroup, OktaApplication, OktaPolicy, OktaPolicyRule } from './types.js';
import { IOktaClient, ApiResponse } from './okta-client-interface.js';
export interface OktaClientConfig {
    domain: string;
    apiToken: string;
}
export declare class OktaClient implements IOktaClient {
    private readonly baseUrl;
    private readonly domain;
    private readonly apiToken;
    constructor(config: OktaClientConfig);
    /**
     * Get authorization header
     */
    private getAuthHeader;
    /**
     * Make an API request to Okta
     */
    private request;
    /**
     * List users with pagination and filtering
     */
    listUsers(params?: {
        limit?: number;
        after?: string;
        filter?: string;
        search?: string;
        status?: string;
        lastUpdated?: string;
        sortBy?: string;
        sortOrder?: 'asc' | 'desc';
    }): Promise<ApiResponse<OktaUser[]>>;
    /**
     * Get a single user by ID or login
     */
    getUser(userIdOrLogin: string): Promise<OktaUser>;
    /**
     * Create a new user
     */
    createUser(userData: {
        profile: Record<string, unknown>;
        credentials?: Record<string, unknown>;
        groupIds?: string[];
    }, queryParams?: {
        activate?: boolean;
        provider?: boolean;
        nextLogin?: string;
    }): Promise<OktaUser>;
    /**
     * Update a user
     */
    updateUser(userId: string, userData: {
        profile?: Record<string, unknown>;
        credentials?: Record<string, unknown>;
    }): Promise<OktaUser>;
    /**
     * Deactivate a user
     */
    deactivateUser(userId: string, sendEmail?: boolean): Promise<void>;
    /**
     * Delete a deactivated user
     */
    deleteUser(userId: string): Promise<void>;
    /**
     * Get groups for a user
     */
    getUserGroups(userId: string, params?: {
        limit?: number;
        after?: string;
    }): Promise<ApiResponse<OktaGroup[]>>;
    /**
     * List groups with pagination and filtering
     */
    listGroups(params?: {
        limit?: number;
        after?: string;
        filter?: string;
        search?: string;
        type?: string;
        sortBy?: string;
        sortOrder?: 'asc' | 'desc';
    }): Promise<ApiResponse<OktaGroup[]>>;
    /**
     * Get a single group by ID
     */
    getGroup(groupId: string): Promise<OktaGroup>;
    /**
     * Create a new group
     */
    createGroup(groupData: {
        profile: {
            name: string;
            description?: string;
        };
    }): Promise<OktaGroup>;
    /**
     * Update a group
     */
    updateGroup(groupId: string, groupData: {
        profile: {
            name?: string;
            description?: string;
        };
    }): Promise<OktaGroup>;
    /**
     * Delete a group
     */
    deleteGroup(groupId: string): Promise<void>;
    /**
     * List members of a group
     */
    listGroupMembers(groupId: string, params?: {
        limit?: number;
        after?: string;
    }): Promise<ApiResponse<OktaUser[]>>;
    /**
     * Add a user to a group
     */
    addGroupMember(groupId: string, userId: string): Promise<void>;
    /**
     * Remove a user from a group
     */
    removeGroupMember(groupId: string, userId: string): Promise<void>;
    /**
     * Get system logs with pagination and filtering
     */
    getLogs(params?: {
        since?: string;
        until?: string;
        filter?: string;
        q?: string;
        limit?: number;
        sortOrder?: 'ASCENDING' | 'DESCENDING';
        after?: string;
    }): Promise<ApiResponse<unknown[]>>;
    /**
     * Check if we have valid authentication
     */
    hasValidAuth(): Promise<boolean>;
    /**
     * List applications with pagination and filtering
     */
    listApps(params?: {
        limit?: number;
        after?: string;
        filter?: string;
        q?: string;
        expand?: string;
    }): Promise<ApiResponse<OktaApplication[]>>;
    /**
     * Get a specific application by ID
     */
    getApp(appId: string, expand?: string): Promise<OktaApplication>;
    /**
     * Create a new application
     */
    createApp(appData: {
        name: string;
        label: string;
        signOnMode: string;
        status?: string;
        accessibility?: Record<string, unknown>;
        visibility?: Record<string, unknown>;
        features?: string[];
        settings?: Record<string, unknown>;
        credentials?: Record<string, unknown>;
        licensing?: Record<string, unknown>;
    }): Promise<OktaApplication>;
    /**
     * Update an application
     */
    updateApp(appId: string, appData: {
        name?: string;
        label?: string;
        status?: string;
        accessibility?: Record<string, unknown>;
        visibility?: Record<string, unknown>;
        features?: string[];
        settings?: Record<string, unknown>;
        credentials?: Record<string, unknown>;
        licensing?: Record<string, unknown>;
    }): Promise<OktaApplication>;
    /**
     * Delete an application
     */
    deleteApp(appId: string): Promise<void>;
    /**
     * Activate an application
     */
    activateApp(appId: string): Promise<void>;
    /**
     * Deactivate an application
     */
    deactivateApp(appId: string): Promise<void>;
    /**
     * Assign a user to an application
     */
    assignUserToApp(appId: string, userId: string, assignmentData?: {
        profile?: Record<string, unknown>;
        credentials?: Record<string, unknown>;
    }): Promise<unknown>;
    /**
     * Assign a group to an application
     */
    assignGroupToApp(appId: string, groupId: string, assignmentData?: {
        priority?: number;
        profile?: Record<string, unknown>;
    }): Promise<unknown>;
    /**
     * Remove a user from an application
     */
    removeUserFromApp(appId: string, userId: string, sendEmail?: boolean): Promise<void>;
    /**
     * Remove a group from an application
     */
    removeGroupFromApp(appId: string, groupId: string): Promise<void>;
    /**
     * List users assigned to an application
     */
    listAppUsers(appId: string, params?: {
        limit?: number;
        after?: string;
        q?: string;
        filter?: string;
        expand?: string;
    }): Promise<ApiResponse<unknown[]>>;
    /**
     * List groups assigned to an application
     */
    listAppGroups(appId: string, params?: {
        limit?: number;
        after?: string;
        q?: string;
        expand?: string;
    }): Promise<ApiResponse<unknown[]>>;
    /**
     * Update a user's app-specific profile or credentials
     */
    updateAppUser(appId: string, userId: string, updateData: {
        profile?: Record<string, unknown>;
        credentials?: Record<string, unknown>;
    }): Promise<unknown>;
    /**
     * Close the client and cleanup resources
     */
    /**
     * List policies by type
     */
    listPolicies(params?: {
        type: string;
        status?: string;
        limit?: number;
        after?: string;
        sortBy?: string;
        sortOrder?: 'asc' | 'desc';
        filter?: string;
    }): Promise<ApiResponse<OktaPolicy[]>>;
    /**
     * Get a specific policy
     */
    getPolicy(policyId: string, expand?: string): Promise<OktaPolicy>;
    /**
     * Create a new policy
     */
    createPolicy(policyData: {
        name: string;
        type: string;
        description?: string;
        priority?: number;
        status?: string;
        conditions?: Record<string, unknown>;
        settings?: Record<string, unknown>;
    }): Promise<OktaPolicy>;
    /**
     * Update a policy
     */
    updatePolicy(policyId: string, policyData: {
        name?: string;
        description?: string;
        priority?: number;
        status?: string;
        conditions?: Record<string, unknown>;
        settings?: Record<string, unknown>;
    }): Promise<OktaPolicy>;
    /**
     * Delete a policy
     */
    deletePolicy(policyId: string): Promise<void>;
    /**
     * Activate a policy
     */
    activatePolicy(policyId: string): Promise<void>;
    /**
     * Deactivate a policy
     */
    deactivatePolicy(policyId: string): Promise<void>;
    /**
     * List policy rules
     */
    listPolicyRules(policyId: string, params?: {
        limit?: number;
        after?: string;
    }): Promise<ApiResponse<OktaPolicyRule[]>>;
    /**
     * Get a specific policy rule
     */
    getPolicyRule(policyId: string, ruleId: string): Promise<OktaPolicyRule>;
    /**
     * Create a policy rule
     */
    createPolicyRule(policyId: string, ruleData: {
        name: string;
        priority?: number;
        status?: string;
        type?: string;
        conditions?: Record<string, unknown>;
        actions?: Record<string, unknown>;
    }): Promise<OktaPolicyRule>;
    /**
     * Update a policy rule
     */
    updatePolicyRule(policyId: string, ruleId: string, ruleData: {
        name?: string;
        priority?: number;
        status?: string;
        conditions?: Record<string, unknown>;
        actions?: Record<string, unknown>;
    }): Promise<OktaPolicyRule>;
    /**
     * Delete a policy rule
     */
    deletePolicyRule(policyId: string, ruleId: string): Promise<void>;
    /**
     * Activate a policy rule
     */
    activatePolicyRule(policyId: string, ruleId: string): Promise<void>;
    /**
     * Deactivate a policy rule
     */
    deactivatePolicyRule(policyId: string, ruleId: string): Promise<void>;
    close(): Promise<void>;
}
//# sourceMappingURL=okta-client.d.ts.map