okta-mcp-server/dist/mocks/mock-okta-client.d.ts

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

import { OktaUser, OktaGroup } from '../lib/types.js';
export interface MockOktaConfig {
    userCount?: number;
    groupCount?: number;
    appCount?: number;
    policyCount?: number;
    seed?: number;
    enableAuth?: boolean;
    enableRateLimit?: boolean;
    enableErrors?: boolean;
    enableDelays?: boolean;
    errorRate?: number;
    networkConditions?: 'fast' | 'normal' | 'slow' | 'unstable';
    rateLimit?: number;
    rateLimitWindow?: number;
}
interface ApiResponse<T> {
    data: T;
    headers?: {
        link?: string;
        [key: string]: string | undefined;
    };
}
export declare class MockOktaClient {
    private config;
    private baseUrl;
    private users;
    private groups;
    private apps;
    private policies;
    private userGroups;
    private groupUsers;
    private auth;
    private rateLimit;
    private error;
    private delay;
    private userGenerator;
    private groupGenerator;
    private appGenerator;
    private policyGenerator;
    constructor(config?: MockOktaConfig);
    private generateInitialData;
    private assignUsersToGroups;
    private simulateRequest;
    listUsers(params?: {
        limit?: number;
        after?: string;
        filter?: string;
        search?: string;
        status?: string;
        lastUpdated?: string;
        sortBy?: string;
        sortOrder?: 'asc' | 'desc';
    }): Promise<ApiResponse<OktaUser[]>>;
    getUser(userIdOrLogin: string): Promise<OktaUser>;
    createUser(userData: {
        profile: Record<string, unknown>;
        credentials?: Record<string, unknown>;
        groupIds?: string[];
    }, queryParams?: {
        activate?: boolean;
        provider?: boolean;
        nextLogin?: string;
    }): Promise<OktaUser>;
    updateUser(userId: string, userData: {
        profile?: Record<string, unknown>;
        credentials?: Record<string, unknown>;
    }): Promise<OktaUser>;
    deactivateUser(userId: string, _sendEmail?: boolean): Promise<void>;
    deleteUser(userId: string): Promise<void>;
    getUserGroups(userId: string, params?: {
        limit?: number;
        after?: string;
    }): Promise<ApiResponse<OktaGroup[]>>;
    listGroups(params?: {
        limit?: number;
        after?: string;
        filter?: string;
        search?: string;
        type?: string;
        sortBy?: string;
        sortOrder?: 'asc' | 'desc';
    }): Promise<ApiResponse<OktaGroup[]>>;
    getGroup(groupId: string): Promise<OktaGroup>;
    createGroup(groupData: {
        profile: {
            name: string;
            description?: string;
        };
    }): Promise<OktaGroup>;
    updateGroup(groupId: string, groupData: {
        profile: {
            name?: string;
            description?: string;
        };
    }): Promise<OktaGroup>;
    deleteGroup(groupId: string): Promise<void>;
    listGroupMembers(groupId: string, params?: {
        limit?: number;
        after?: string;
    }): Promise<ApiResponse<OktaUser[]>>;
    addGroupMember(groupId: string, userId: string): Promise<void>;
    removeGroupMember(groupId: string, userId: string): Promise<void>;
    reset(): void;
    getStats(): any;
    setErrorRate(rate: number): void;
    setNetworkConditions(conditions: 'fast' | 'normal' | 'slow' | 'unstable'): void;
    simulateRateLimitScenario(scenario: 'normal' | 'warning' | 'exhausted' | 'recovering'): void;
    getLogs(params?: {
        since?: string;
        until?: string;
        filter?: string;
        q?: string;
        limit?: number;
        sortOrder?: 'ASCENDING' | 'DESCENDING';
        after?: string;
    }): Promise<ApiResponse<unknown[]>>;
    close(): Promise<void>;
}
export {};
//# sourceMappingURL=mock-okta-client.d.ts.map