> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/wazuh/wazuh-dashboard-plugins/llms.txt
> Use this file to discover all available pages before exploring further.

# Wazuh Core Plugin API

> API reference for the Wazuh Core shared services plugin

The Wazuh Core plugin provides shared services, configuration management, security utilities, and API client functionality used by all other Wazuh plugins.

## Plugin Class

### WazuhCorePlugin

**Location:** `plugins/wazuh-core/public/plugin.ts:20`

```typescript theme={null}
export class WazuhCorePlugin
  implements Plugin<WazuhCorePluginSetup, WazuhCorePluginStart>
```

## Lifecycle Methods

### setup()

Initializes core services during the setup phase.

**Signature:**

```typescript theme={null}
public async setup(core: CoreSetup): Promise<WazuhCorePluginSetup>
```

**core** `CoreSetup` *required*

OpenSearch Dashboards core setup contract

**Returns:** `Promise<WazuhCorePluginSetup>`

**configuration** `Configuration`

Configuration service for reading and managing plugin settings

**dashboardSecurity** `DashboardSecurity`

Security utilities for authentication and authorization

**utils** `object`

Utility functions

**properties**

**formatUIDate** `(date: Date) =\> string`

Formats a Date object for UI display

**API\_USER\_STATUS\_RUN\_AS** `object`

Constants for run\_as API user statuses

**SettingsValidator** `class`

Validation utilities for settings

**Example:**

```typescript theme={null}
export class MyPlugin implements Plugin {
  public setup(core: CoreSetup, plugins: { wazuhCore: WazuhCorePluginSetup }) {
    // Access configuration
    const config = plugins.wazuhCore.configuration;
    
    // Use dashboard security
    const security = plugins.wazuhCore.dashboardSecurity;
    
    // Use utilities
    const formatted = plugins.wazuhCore.utils.formatUIDate(new Date());
  }
}
```

### start()

Activates services during the start phase.

**Signature:**

```typescript theme={null}
public async start(core: CoreStart): Promise<WazuhCorePluginStart>
```

**core** `CoreStart` *required*

OpenSearch Dashboards core start contract

**Returns:** `Promise<WazuhCorePluginStart>`

**configuration** `Configuration`

Active configuration service instance

**dashboardSecurity** `DashboardSecurity`

Active security service instance

**hooks** `object`

React hooks for UI components

**properties**

**useDockedSideNav** `() =\> boolean`

Hook to detect if side navigation is docked

**utils** `object`

Utility functions (same as setup)

## Configuration Service

Manages plugin configuration from multiple sources.

### Configuration

**Location:** `plugins/wazuh-core/common/services/configuration.ts`

#### get()

Retrieve a configuration value.

**Signature:**

```typescript theme={null}
get<T = any>(settingKey: string): Promise<T>
```

**settingKey** `string` *required*

The setting key to retrieve

**Returns:** `Promise<T>` - The configuration value

**Example:**

```typescript theme={null}
import { getWazuhCorePlugin } from './plugin-services';

const wazuhCore = getWazuhCorePlugin();

// Get index pattern
const pattern = await wazuhCore.configuration.get('pattern');
// => "wazuh-alerts-*"

// Get timeout setting
const timeout = await wazuhCore.configuration.get('timeout');
// => 20000
```

#### set()

Update a configuration value.

**Signature:**

```typescript theme={null}
set(settingKey: string, value: any): Promise<void>
```

**settingKey** `string` *required*

The setting key to update

**value** `any` *required*

The new value

**Example:**

```typescript theme={null}
// Update timeout
await wazuhCore.configuration.set('timeout', 30000);

// Update index pattern
await wazuhCore.configuration.set('pattern', 'wazuh-alerts-4.x-*');
```

#### Common Settings

**pattern** `string` (default: wazuh-alerts-\*)

Default index pattern for Wazuh alerts

**timeout** `number` (default: 20000)

Request timeout in milliseconds

**ip.selector** `boolean` (default: true)

Enable/disable IP selector in UI

**ip.ignore** `string[]`

IP addresses to exclude from monitoring

**logs.level** `string` (default: info)

Logging level (info, debug, error)

**hideManagerAlerts** `boolean` (default: false)

Hide alerts from manager in visualizations

## Dashboard Security Service

Handles authentication, authorization, and security platform detection.

### DashboardSecurity

**Location:** `plugins/wazuh-core/public/utils/dashboard-security.ts`

#### fetchCurrentPlatform()

Detects the current security platform.

**Signature:**

```typescript theme={null}
fetchCurrentPlatform(): Promise<string>
```

**Returns:** Platform identifier

**platform** `string`

One of: 'opensearch', 'xpack', or empty string if no security

**Example:**

```typescript theme={null}
const platform = await wazuhCore.dashboardSecurity.fetchCurrentPlatform();

if (platform === 'opensearch') {
  // OpenSearch Security is active
} else if (platform === 'xpack') {
  // Elastic X-Pack security is active
}
```

#### fetchCurrentUser()

Retrieves the current authenticated user.

**Signature:**

```typescript theme={null}
fetchCurrentUser(): Promise<{
  username: string,
  authContext: any
}>
```

**Returns:** User information

**username** `string`

The username of the authenticated user

**authContext** `object`

Additional authentication context (platform-specific)

**Example:**

```typescript theme={null}
const user = await wazuhCore.dashboardSecurity.fetchCurrentUser();
console.log(`Logged in as: ${user.username}`);
```

#### fetchCurrentUserRoles()

Retrieves roles for the current user.

**Signature:**

```typescript theme={null}
fetchCurrentUserRoles(): Promise<string[]>
```

**Returns:** `Promise<string[]>` - Array of role names

**Example:**

```typescript theme={null}
const roles = await wazuhCore.dashboardSecurity.fetchCurrentUserRoles();

if (roles.includes('administrator')) {
  // User has admin privileges
}
```

#### hasDashboardSecurity()

Checks if a security platform is enabled.

**Signature:**

```typescript theme={null}
hasDashboardSecurity(): Promise<boolean>
```

**Example:**

```typescript theme={null}
const hasecurity = await wazuhCore.dashboardSecurity.hasDashboardSecurity();

if (!hasSecurity) {
  // Show security warning
}
```

## Server Plugin

The server-side Core plugin provides API clients and host management.

### WazuhCorePlugin (Server)

**Location:** `plugins/wazuh-core/server/plugin.ts:28`

### setup() (Server)

**Signature:**

```typescript theme={null}
public async setup(
  core: CoreSetup,
  plugins: PluginSetup
): Promise<WazuhCorePluginSetup>
```

**Returns:** Server setup contract

**dashboardSecurity** `ISecurityFactory`

Server-side security factory

**configuration** `IConfigurationEnhanced`

Server configuration service

**manageHosts** `ManageHosts`

API host management service

**serverAPIClient** `ServerAPIClient`

Wazuh API client

**api** `object`

API client interfaces

**properties**

**client.asInternalUser** `ServerAPIInternalUserClient`

API client using internal credentials

**client.asScoped** `Function`

Creates a scoped client for the current request user

### Server API Client

Makes authenticated requests to the Wazuh API.

#### request() (asCurrentUser)

Make an API request as the current user.

**Signature:**

```typescript theme={null}
request(
  method: string,
  path: string,
  data: any,
  options: { apiHostID: string; forceRefresh?: boolean }
): Promise<any>
```

**method** `string` *required*

HTTP method (GET, POST, PUT, DELETE)

**path** `string` *required*

API endpoint path

**data** `object` *required*

Request body

**options.apiHostID** `string` *required*

API host identifier

**options.forceRefresh** `boolean` (default: false)

Force token refresh

**Example:**

```typescript theme={null}
// In a route handler
router.get(
  { path: '/api/agents/summary', validate: false },
  async (context, request, response) => {
    try {
      const result = await context.wazuh_core.api.client.asCurrentUser.request(
        'GET',
        '/agents/summary/status',
        {},
        { apiHostID: 'default' }
      );
      
      return response.ok({ body: result });
    } catch (error) {
      return response.customError({
        statusCode: error.statusCode || 500,
        body: { message: error.message }
      });
    }
  }
);
```

#### authenticate()

Authenticate and retrieve an API token.

**Signature:**

```typescript theme={null}
authenticate(apiHostID: string): Promise<string>
```

**apiHostID** `string` *required*

API host identifier

**Returns:** `Promise<string>` - Authentication token

**Example:**

```typescript theme={null}
const token = await context.wazuh_core.api.client.asCurrentUser.authenticate('default');
```

## Request Handler Context

The Core plugin extends the request handler context.

**Type Definition:**

```typescript theme={null}
declare module 'opensearch_dashboards/server' {
  interface RequestHandlerContext {
    wazuh_core: {
      configuration: IConfigurationEnhanced;
      dashboardSecurity: ISecurityFactory;
      manageHosts: ManageHosts;
      serverAPIClient: ServerAPIClient;
      api: {
        client: {
          asInternalUser: ServerAPIInternalUserClient;
          asCurrentUser: ServerAPIScopedUserClient;
        };
      };
    };
  }
}
```

**Usage:**

```typescript theme={null}
router.get(
  { path: '/my-endpoint', validate: false },
  async (context, request, response) => {
    // Access Core services via context
    const config = context.wazuh_core.configuration;
    const security = context.wazuh_core.dashboardSecurity;
    const api = context.wazuh_core.api.client.asCurrentUser;
    
    // Make API request
    const agents = await api.request(
      'GET',
      '/agents',
      {},
      { apiHostID: 'default' }
    );
    
    return response.ok({ body: agents });
  }
);
```

## Utilities

### formatUIDate()

Formats a Date object for consistent UI display.

**Signature:**

```typescript theme={null}
formatUIDate(date: Date): string
```

**date** `Date` *required*

Date to format

**Returns:** Formatted date string

**Example:**

```typescript theme={null}
import { getWazuhCorePlugin } from './plugin-services';

const formatted = getWazuhCorePlugin().utils.formatUIDate(new Date());
// => "2026-03-04 10:30:45"
```

## Hooks

### useDockedSideNav()

React hook to determine if side navigation is docked.

**Signature:**

```typescript theme={null}
function useDockedSideNav(): boolean
```

**Returns:** `boolean` - True if side nav is docked

**Example:**

```typescript theme={null}
import React from 'react';
import { getWazuhCorePlugin } from './plugin-services';

function MyComponent() {
  const { useDockedSideNav } = getWazuhCorePlugin().hooks;
  const isDocked = useDockedSideNav();
  
  return (
    <div className={isDocked ? 'with-docked-nav' : 'without-docked-nav'}>
      Content
    </div>
  );
}
```

## Constants

### API\_USER\_STATUS\_RUN\_AS

Status codes for run\_as API user configuration.

**Location:** `plugins/wazuh-core/common/api-user-status-run-as.ts`

```typescript theme={null}
export const API_USER_STATUS_RUN_AS = {
  ALL_DISABLED: 0,
  USER_NOT_ALLOWED: 1,
  HOST_DISABLED: 2,
  ENABLED: 3,
} as const;
```

**Usage:**

```typescript theme={null}
import { API_USER_STATUS_RUN_AS } from 'plugins/wazuh-core/public';

if (status === API_USER_STATUS_RUN_AS.ENABLED) {
  // run_as is enabled
}
```

## Related Resources

> **[Main Plugin API](/api/main-plugin)**
>
> Main dashboard plugin reference

> **[Configuration](/configuration/settings)**
>
> Plugin configuration guide

> **[Security](/configuration/authentication)**
>
> Security configuration

> **[API Client](/api/console)**
>
> API console usage


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.