Dt Js Runtime

Available APIs & Modules

What you can import and call inside the Dynatrace server-side JS runtime. For quotas and forbidden constructs see limits-and-restrictions.md; for HTTP details see fetch.md.

Standard built-ins

All standard JavaScript (ECMAScript) built-ins are supported, plus the ECMAScript Internationalization API (Intl).

Web APIs

Available Web/Web-platform APIs include:

• Fetch — fetch, Request, Response, Headers (see fetch.md)
• Streams — ReadableStream, WritableStream, TransformStream
• Compression — CompressionStream, DecompressionStream
• Web Crypto — crypto, crypto.subtle (SubtleCrypto)
• Encoding — TextEncoder, TextDecoder, atob, btoa
• Performance — performance timing
• Events & timers — event handling, setTimeout/setInterval
• `structuredClone`, URL, URLSearchParams

Deprecated properties of Web APIs might not be supported.

Node.js compatibility modules

A compatibility layer exposes a subset of Node.js core modules:

Not supported: third-party packages that rely on TCP/UDP sockets or filesystem access.

Full reference: https://developer.dynatrace.com/develop/reference/javascript-runtime/

HTTP Fetch — Internal & External

How to make HTTP calls from the runtime. Quotas in limits-and-restrictions.md; the fetch API itself is listed in apis-and-modules.md.

Internal Dynatrace API (relative path)

Call the platform's own APIs with a relative path — no host, no auth header. The runtime injects credentials automatically, and relative paths bypass the outbound allowlist.

const res = await fetch("/platform/classic/environment-api/v2/settings/objects?...");
const data = await res.json();

Prefer the typed @dynatrace-sdk/* clients (see sdk.md) over hand-rolled relative fetches when a client exists.

External URL with credential vault

For external hosts, pull secrets from the credential vault rather than hardcoding them:

import { credentialVaultClient } from "@dynatrace-sdk/client-classic-environment-v2";

const creds = await credentialVaultClient.getCredentialsDetails({ id: "CREDENTIALS_VAULT-..." });
const auth = `Basic ${btoa(`${creds.username}:${creds.password}`)}`;
const res = await fetch("https://api.example.com/...", { headers: { Authorization: auth } });

See classic-environment-v2 for the credential vault client.

Outbound allowlist

The tenant controls which external hosts are reachable via the setting builtin:dt-javascript-runtime.allowed-outbound-connections. If an external fetch silently fails, the host is most likely not allowlisted.

Inspect the current allowlist:

dtctl get settings --schema "builtin:dt-javascript-runtime.allowed-outbound-connections" -o json

Only full-URL fetches are gated by the allowlist; relative /platform/... paths are not.

Runtime Limits & Restrictions

Hard quotas and unavailable capabilities of the Dynatrace server-side JS runtime.

Limits

Not available

• Inter-app function calls — a function cannot invoke another app's function.
• Binary responses — functions cannot return raw binary payloads.
• WebSocket API — not available.
• Raw TCP/UDP sockets — not available; only HTTP(S) via fetch / the Node http/https client.
• Filesystem access — not available. Third-party packages that rely on sockets or the filesystem will not work.

Forbidden constructs

• eval() — disabled (security).
• new Function() — disabled (security).
• globalThis.window — deprecated; unreliable for browser detection and should not be used.

Deprecated properties of otherwise-supported Web APIs may also be unavailable — see apis-and-modules.md.

Full reference: https://developer.dynatrace.com/develop/reference/javascript-runtime/

Dynatrace SDK for TypeScript — Index

The @dynatrace-sdk/* packages expose Dynatrace platform services to runtime code. Two layers:

• Generic / utility packages — convenience helpers (e.g. units for formatting, app-environment for app/user context).
• *Low-level `client-`** packages — direct, scope-gated access to individual platform services.

Rules of thumb

• The app/function must declare the OAuth scopes for every service it touches (each SDK file lists them).
• Error handling: wrap calls in try/catch, treat the error as unknown, narrow with type guards, handle only what you can act on, and rethrow the rest so monitoring detects it.
• Prefer a typed client over a hand-rolled relative fetch (see fetch.md).

Catalog

Load the per-SDK file for methods, scopes, and examples.

Full SDK reference: https://developer.dynatrace.com/develop/sdks/

appEngineRegistryAppsClient

Install, query, and run-search AppEngine apps. Import:

import { appEngineRegistryAppsClient } from "@dynatrace-sdk/client-app-engine-registry";

Install/uninstall are asynchronous — inspect the returned status / pending-operation fields.

Example

import { appEngineRegistryAppsClient } from "@dynatrace-sdk/client-app-engine-registry";

const stub = await appEngineRegistryAppsClient.installApp({ body: new Blob() });

appEngineRegistrySchemaManifestClient

App manifest schema and default CSP. Import:

import { appEngineRegistrySchemaManifestClient } from "@dynatrace-sdk/client-app-engine-registry";

Example

import { appEngineRegistrySchemaManifestClient } from "@dynatrace-sdk/client-app-engine-registry";

const schema = await appEngineRegistrySchemaManifestClient.getAppManifestSchema();

AppEngine Registry (@dynatrace-sdk/client-app-engine-registry)

Env: ✅ Server runtime

Status: current

Manage Dynatrace AppEngine apps — install, update, uninstall, and discover apps and their actions.

Clients & key methods

Full method/type detail: appEngineRegistryAppsClient.md, appEngineRegistrySchemaManifestClient.md (per-method returns, scopes, examples) · types.md (types + enums).

Required scopes

• app-engine:apps:run, app-engine:apps:install, app-engine:apps:delete (per operation).

Example

import { appEngineRegistryAppsClient } from "@dynatrace-sdk/client-app-engine-registry";

const app = await appEngineRegistryAppsClient.getApp({ id: "my.app" });
const apps = await appEngineRegistryAppsClient.getApps();

Notes

• App IDs follow namespace convention (dynatrace.*, my.*).
• Install/uninstall are asynchronous; resources carry a status / PendingOperation / DeploymentStatus reflecting in-progress operations.
• Filtering supports up to 3 nesting levels / 256-char limits.

Canonical reference: https://developer.dynatrace.com/develop/sdks/client-app-engine-registry/

AppEngine Registry — Types & Enums

Full field definitions: https://developer.dynatrace.com/develop/sdks/client-app-engine-registry/#types

App info types

AppInfo, AppInfoList, AppStub, AppIcon, AppIsolatedUri, AppSignatureInfo, ModificationInfo, ResourceContext, ResourceStatus, Warning.

CSP types

AppDefaultCsp, AppDefaultCspPolicyDirectives.

Action search types

SearchAppAction, SearchAppActionList.

Error types

Error, ErrorDetails, ErrorDetailsErrorCodeProperties, ErrorEnvelope, ConstraintViolation, ConstraintViolationErrorCodeProperties, SubResourceError, SubResourceConstraintViolation, SubResourceStatus.

Enums

Status, DeploymentStatus, PendingOperation, DeactivationReason, OperationStateBeforeError, ConstraintViolationErrorCode, ErrorDetailsErrorCode, ResourceContextOperationsItem, SubResourceType.

App Environment — Functions

Import individually from @dynatrace-sdk/app-environment.

Example

import { getAppId, getCurrentUserDetails } from "@dynatrace-sdk/app-environment";

const appId = getAppId();
const { id, name, email } = getCurrentUserDetails();

App Environment (@dynatrace-sdk/app-environment)

Env: ✅ Server runtime

Status: current

Basic information about the app and the environment it runs in.

Key exports

Full detail: functions.md (per-function signatures + examples) · types.md (UserDetails). All exports are synchronous functions — no clients, no scopes.

Example

import { getAppId, getCurrentUserDetails } from "@dynatrace-sdk/app-environment";

const appId = getAppId();
const { id, name, email } = getCurrentUserDetails();

Notes

• If the Dynatrace JS runtime is unavailable, functions return placeholder values prefixed "dt.missing." and log a console warning.

Canonical reference: https://developer.dynatrace.com/develop/sdks/app-environment/

App Environment — Types

Full field definitions: https://developer.dynatrace.com/develop/sdks/app-environment/#types

• `UserDetails` — returned by getCurrentUserDetails(). Fields: id, name, email.

appSettingsObjectsClient

DEPRECATED — migrate to app-settings-v2.

Import:

import { appSettingsObjectsClient } from "@dynatrace-sdk/client-app-settings";

Example

import { appSettingsObjectsClient } from "@dynatrace-sdk/client-app-settings";

const data = await appSettingsObjectsClient.getEffectiveAppSettingsValues();

App Settings v1 (@dynatrace-sdk/client-app-settings)

Env: ✅ Server runtime

Status: ⚠ DEPRECATED — use app-settings-v2 instead

Retrieve, update, and manage app settings objects. This API version is deprecated; new code should use v2.

Clients & key methods

appSettingsObjectsClient — postAppSettingsObject, getAppSettingsObjectByObjectId, putAppSettingsObjectByObjectId, deleteAppSettingsObjectByObjectId, getAppSettingsObjects, getEffectiveAppSettingsValues, resolveEffectivePermissions.

Full method/type detail: appSettingsObjectsClient.md · types.md. V2 adds richer per-object permission and ownership management — migrate to it.

Required scopes

• app-settings:objects:read / app-settings:objects:write.

Notes

• Migrate to v2; the surface is largely the same.
• Secret properties appear unmasked in serverless functions, masked elsewhere.

Canonical reference: https://developer.dynatrace.com/develop/sdks/client-app-settings/

App Settings V1 — Types

DEPRECATED SDK. Full field definitions: https://developer.dynatrace.com/develop/sdks/client-app-settings/#types

Settings object, effective-value, effective-permission, and error types mirror their V2 counterparts. See app-settings-v2/types.md for the current, fuller type set and migrate accordingly.

appSettingsObjectsClient

Manage app settings objects, effective values, and permissions. Import:

import { appSettingsObjectsClient } from "@dynatrace-sdk/client-app-settings-v2";

Objects & effective values

Permissions

Example

import { appSettingsObjectsClient } from "@dynatrace-sdk/client-app-settings-v2";

await appSettingsObjectsClient.postAppSettingsObject({
  body: { schemaId: "jira-connection", value: {} },
});
const effective = await appSettingsObjectsClient.getEffectiveAppSettingsValues();

App Settings v2 (@dynatrace-sdk/client-app-settings-v2)

Env: ✅ Server runtime

Status: current (replaces app-settings-v1)

Retrieve, update, and manage app settings objects, including permissions and ownership.

Clients & key methods

Full method/type detail: appSettingsObjectsClient.md (per-method returns, scopes, examples) · types.md (types + enums).

Required scopes

• app-settings:objects:read / app-settings:objects:write.

Example

import { appSettingsObjectsClient } from "@dynatrace-sdk/client-app-settings-v2";

const data = await appSettingsObjectsClient.postAppSettingsObject({
  body: { schemaId: "jira-connection", value: {} },
});

Concepts

• Effective values: for multiObject: false schemas with no persisted object, the schema default is returned by getEffectiveAppSettingsValues.
• Secrets: secret properties are returned in plain text only when the call originates from your app's serverless function; otherwise irreversibly masked.
• Optimistic locking: mutations use version tokens.
• Pagination: when using page-key for subsequent pages, omit all other query params (same gotcha as classic settings — see classic-environment-v2). Max pageSize 500 (0 = all), default 100.
• Permissions model: per-object accessor permissions + an all-users permission; ownership transfer via postAppSettingsOwnershipByObjectId (owner or main admin only).

Canonical reference: https://developer.dynatrace.com/develop/sdks/client-app-settings-v2/

App Settings V2 — Types & Enums

Full field definitions: https://developer.dynatrace.com/develop/sdks/client-app-settings-v2/#types

Object types

AppSettingsObject, AppSettingsObjectCreate, AppSettingsObjectUpdate, AppSettingsObjectResponse, AppSettingsObjectsList, AppSettingsUpdateResponse, EffectiveAppSettingsValue, EffectiveAppSettingsValuesList, ModificationInfo, Modifications, ResourceContext.

Permission types

AppSettingsAccessorPermissions, AppSettingsAccessorPermissionsList, AppSettingsPermissionsList, AppSettingsUpdatePermissionsRequest, AppSettingsTransferOwnershipRequest, EffectivePermission, EffectivePermissions, PermissionContext, ResolutionRequest, SinglePermissionRequest, Identity.

Error types

Error, ErrorDetails, ErrorIncomplete, ErrorResponse, ConstraintViolation.

Enums

AppSettingsPermissionsListItem, EffectivePermissionGranted, GetAppSettingsPermissionByObjectIdAndAccessorIdPathAccessorType, IdentityType, ResourceContextOperationsItem, SinglePermissionRequestPermission.

App Utils (@dynatrace-sdk/app-utils)

Env: ✅ Server runtime

Status: current

Utilities for app function executions — call a named app function programmatically.

Key exports

Example

import { functions } from "@dynatrace-sdk/app-utils";

const res = await functions.call("my-function", { data: { foo: "bar" } });
const result = await res.json();

Notes

• Returns a standard Response; supports cancellation via abortSignal.

Canonical reference: https://developer.dynatrace.com/develop/sdks/app-utils/

Automation Utils — Constants

Import from @dynatrace-sdk/automation-utils. Injected values describing the current execution context.

Automation Utils — Functions

Import from @dynatrace-sdk/automation-utils.

Examples

import { execution, result } from "@dynatrace-sdk/automation-utils";

const exe = await execution();
const eventContext = exe.event();
const prev = await result("predecessor_task_1");

Automation Utils (@dynatrace-sdk/automation-utils)

Env: ✅ Server runtime (inside workflow Run JavaScript actions)

Status: current

Helper functions for accessing AutomationEngine context from within a Run JavaScript action. For full workflow management see automation.

Key exports

IExecution adds event() (trigger event payload as key-value) and result(taskId).

Full detail: functions.md (per-function signatures + examples) · constants.md · types.md (IExecution).

Required scopes

• automation:workflows:read for most operations.

Example

import { execution, result } from "@dynatrace-sdk/automation-utils";

const exec = await execution();
const prev = await result("fetch_data");

Notes

• Available for standard workflows only — simple workflows return 404.

Canonical reference: https://developer.dynatrace.com/develop/sdks/automation-utils/

Automation Utils — Types

Full field definitions: https://developer.dynatrace.com/develop/sdks/automation-utils/#types

• `IExecution` — returned by execution(). Provides execution metadata plus methods event() (trigger/event context) and result(taskName) (task result).

actionExecutionsClient

Read action executions. Import:

import { actionExecutionsClient } from "@dynatrace-sdk/client-automation";

actionsSampleResultClient

Read action sample results. Import:

import { actionsSampleResultClient } from "@dynatrace-sdk/client-automation";

businessCalendarsClient

Manage business calendars (working days/holidays referenced by schedules). Import:

import { businessCalendarsClient } from "@dynatrace-sdk/client-automation";

eventTriggersClient

Preview event-trigger filters. Import:

import { eventTriggersClient } from "@dynatrace-sdk/client-automation";

executionsClient

Control and inspect workflow executions and task executions. Import:

import { executionsClient } from "@dynatrace-sdk/client-automation";

Example

import { executionsClient } from "@dynatrace-sdk/client-automation";

const exec = await executionsClient.getExecution({ id: "..." });
const result = await executionsClient.getTaskExecutionResult({ executionId: "...", id: "..." });

Automation (@dynatrace-sdk/client-automation)

Env: ✅ Server runtime

Status: current

Manage and execute workflows via the AutomationEngine API. For helpers used inside a workflow's Run JavaScript action, see automation-utils.

Clients & key methods

Full method/type detail (per client): workflowsClient.md, executionsClient.md, schedulingRulesClient.md, businessCalendarsClient.md, schedulesClient.md, settingsClient.md, eventTriggersClient.md, actionExecutionsClient.md, actionsSampleResultClient.md, webhookHandlersClient.md, versionClient.md · types.md.

Required scopes

• automation:workflows:read (reads: get/export/list/preview), automation:workflows:write (mutations: create/update/patch/delete/duplicate/restore), automation:workflows:run (execution control: run/cancel/pause/resume); admin ops also need automation:workflows:admin.

Example

import { workflowsClient } from "@dynatrace-sdk/client-automation";

const execution = await workflowsClient.runWorkflow({
  id: "workflow-uuid",
  body: { input: {}, params: {} },
});

Notes

• Several methods are deprecated (flagged in the official docs).

Canonical reference: https://developer.dynatrace.com/develop/sdks/client-automation/

schedulesClient

Preview schedules and look up calendar reference data. Import:

import { schedulesClient } from "@dynatrace-sdk/client-automation";

schedulingRulesClient

Manage scheduling rules (date/offset rules used by schedules). Import:

import { schedulingRulesClient } from "@dynatrace-sdk/client-automation";

settingsClient

Automation settings, service users, and permissions. Import:

import { settingsClient } from "@dynatrace-sdk/client-automation";

Automation — Types & Enums

Full field definitions: https://developer.dynatrace.com/develop/sdks/client-automation/#types

Workflow types

Workflow, WorkflowCreate, WorkflowUpdate, WorkflowInput, WorkflowList, WorkflowExport, WorkflowTemplate, WorkflowDefinitionTemplate, WorkflowTaskDefaults, WorkflowLimit, WorkflowThrottlesResetStatus, Task, Tasks, TaskInput, TaskPosition, TaskTransition, TaskTransitions, TaskRetryOption, TaskConditionOption, Throttle, ThrottleRequest, ThrottleLimitEvent(s).

Execution types

Execution, ExecutionInput, ExecutionParams, ExecutionLimits, ExecutionInputsRequest, ExecutionProvidedInput, PaginatedExecutionList, ActionExecution, ActionExecutionInput, ActionExecutionLoopItem, TaskExecution(s), TaskExecutionInput, TaskExecutionConditions, EventLog(s), EventLogContext.

Trigger types

Trigger, TriggerRequest, TriggerExport, EventTrigger, EventTriggerRequest, EventTriggerExport, EventTriggerPreviewRequest, EventTriggerPreviewResponse, EventQuery, EventQueryTriggerConfig, EventTriggerConfig, CronTrigger, IntervalTrigger, OnceTrigger, TimeTrigger, ScheduleTrigger, TriggerManualDetail, plus Davis configs (DavisEventConfig, DavisEventTriggerConfig, DavisProblemConfig, DavisProblemTriggerConfig, EntityTags).

Schedule / rule / calendar types

Schedule, ScheduleExport, ScheduleInput(s), ScheduleRequest, SchedulePreviewRequest, SchedulePreviewResponse, ScheduleFilterParameters, Rule, RuleCreate, RuleUpdate, RulePreviewResponse, RRule, FixedOffsetRule, RelativeOffsetRule, GroupingRule, BusinessCalendarCreate/Response/Update, Country(List), Holiday(s), HolidayCalendarList, Weekdays(Names/Values).

Settings / webhook / misc

GetSettingsResponse, UserSettings, GetServiceUsersResponse, WebhookHandler, WebhookHandlerList, VersionResponse, ChangeHistory, PaginatedChangeHistory, ModificationInfo, Source, EnvironmentObject, DuplicationRequest.

Error types

Error, ErrorDetails, ErrorEnvelope.

Enums

ExecutionState, ActionExecutionState, TaskExecutionState, EventLogState, WorkflowType, OwnerType, GetWorkflowsQueryOwnerType, TriggerType, TriggerSubType, RuleType, Freq, Byday, Byworkday, Wkst, Direction, Timezone, ValidationMethod, HmacSignatureEncoding, MaintenanceWindowTriggerBehaviorType, EventType, and the preview/trigger config enums.

versionClient

AutomationEngine version. Import:

import { versionClient } from "@dynatrace-sdk/client-automation";

webhookHandlersClient

Manage webhook handlers. Import:

import { webhookHandlersClient } from "@dynatrace-sdk/client-automation";

workflowsClient

Workflow lifecycle, templates, execution, and history. Import:

import { workflowsClient } from "@dynatrace-sdk/client-automation";

Example

import { workflowsClient } from "@dynatrace-sdk/client-automation";

const wf = await workflowsClient.createWorkflow({ body: { title: "My workflow" } });
const execution = await workflowsClient.runWorkflow({ id: wf.id, body: { input: {}, params: {} } });

bucketDefinitionsClient

Manage Grail bucket definitions. Import:

import { bucketDefinitionsClient } from "@dynatrace-sdk/client-bucket-management";

Example

import { bucketDefinitionsClient } from "@dynatrace-sdk/client-bucket-management";

await bucketDefinitionsClient.updateBucketPartially({
  bucketName: "custom_logs",
  optimisticLockingVersion: 10,
  body: { displayName: "Custom logs (updated)", retentionDays: 10 },
});

Grail Bucket Management (@dynatrace-sdk/client-bucket-management)

Env: ✅ Server runtime

Status: current

Manage Grail storage buckets — creation, retention, truncation.

Clients & key methods

Full method/type detail: bucketDefinitionsClient.md (per-method returns, scopes, examples) · types.md (types + enums).

Required scopes

• storage:bucket-definitions:read / storage:bucket-definitions:write / storage:bucket-definitions:delete.

Example

import { bucketDefinitionsClient } from "@dynatrace-sdk/client-bucket-management";

const data = await bucketDefinitionsClient.createBucket({
  body: { bucketName: "custom_logs", table: "logs", displayName: "Custom logs", retentionDays: 35 },
});

Notes

• Bucket name: 3–100 chars, starts with a letter, lowercase/numbers/_/- only; no default_/dt_ prefix; immutable after creation.
• Retention 1–3657 days; shortening it triggers automatic data deletion.
• Mandatory optimistic locking (version) on updates.
• Creation can take up to 1 minute to appear; delete/truncate are irreversible async operations.

Canonical reference: https://developer.dynatrace.com/develop/sdks/client-bucket-management/

Bucket Management — Types & Enums

Full field definitions: https://developer.dynatrace.com/develop/sdks/client-bucket-management/#types

Bucket types

Bucket, Buckets, CreateBucket, UpdateBucket, PartialUpdateBucket.

Error types

ErrorEnvelope, ErrorInfo, ExceptionalReturn, CustomValidationErrorInfo, InvalidAuditEventsErrorInfo, MediaTypeErrorInfo, ParameterErrorInfo, ProxyErrorInfo, QueryFrontendRawErrorInfo, RequestBodyErrorInfo.

Enums

BucketStatus, UpdateBucketStatus, BucketMetricInterval, CreateBucketMetricInterval, UpdateBucketMetricInterval, GetDefinitionQueryAddFieldsItem, GetDefinitionsQueryAddFieldsItem.

Cluster clients

Cluster identity and version. Import from @dynatrace-sdk/client-classic-environment-v1.

clusterConfigClient

clusterVersionClient

deploymentClient

OneAgent/ActiveGate installer downloads, orchestration, BOSH releases, and Lambda layers. Import:

import { deploymentClient } from "@dynatrace-sdk/client-classic-environment-v1";

Installers

Orchestration, BOSH, images, Lambda

oneAgentOnAHostClient

Query hosts by OneAgent characteristics and manage persisted potential problems. Import:

import { oneAgentOnAHostClient } from "@dynatrace-sdk/client-classic-environment-v1";

Classic Environment v1 (@dynatrace-sdk/client-classic-environment-v1)

Env: ✅ Server runtime

Status: current (many resources superseded by classic-environment-v2)

Client for the Dynatrace Classic Environment API v1: OneAgent/ActiveGate deployment, synthetic monitors, RUM JavaScript, and user-session queries (USQL).

Clients & key methods

Full method/type detail (per client): deployment.md, oneagent-on-host.md, rum-javascript-tags.md, rum-user-sessions.md, synthetic.md, cluster.md · types.md.

Required scopes

• Various environment-api:* scopes plus specific viewer/management permissions per operation.

Example

import { deploymentClient } from "@dynatrace-sdk/client-classic-environment-v1";

const installer = await deploymentClient.downloadLatestAgentInstaller({
  osType: "windows",
  installerType: "default",
});

Notes

• Prefer v2 where a resource exists there.
• Early-adopter/preview operations may change incompatibly; new enum constants may be added without a version bump.

Canonical reference: https://developer.dynatrace.com/develop/sdks/client-classic-environment-v1/

rumJavaScriptTagManagementClient

Manage RUM JavaScript tags, snippets, and versions for manual web instrumentation. Import:

import { rumJavaScriptTagManagementClient } from "@dynatrace-sdk/client-classic-environment-v1";

rumUserSessionsClient

Query user-session data with USQL (User Session Query Language). Import:

import { rumUserSessionsClient } from "@dynatrace-sdk/client-classic-environment-v1";

For new code, prefer DQL via client-query over USQL.

Synthetic clients (v1)

Synthetic monitors and locations/nodes. Import from @dynatrace-sdk/client-classic-environment-v1.

syntheticMonitorsClient

syntheticLocationsNodesAndConfigurationClient

Classic Environment v1 — Types & Enums

Full field definitions: https://developer.dynatrace.com/develop/sdks/client-classic-environment-v1/#types Full enum definitions (deprecated in favor of literal values): https://developer.dynatrace.com/develop/sdks/client-classic-environment-v1/#enums

Deployment / installer types

AgentInstallerMetaInfoDto, AgentInstallerVersions, AllAvailableVersions, ActiveGateInstallerVersions, ActiveGateConnectionInfo, ConnectionInfo, Address(es), AgentProcessModuleConfigResponse, BoshReleaseAvailableVersions, BoshReleaseChecksum, OneAgentInstallerChecksum, GatewayInstallerMetaInfoDto, ImageDto, LambdaDto, LatestLambdaLayerNames, LatestLambdaLayersMetainfo, ModuleInfo, PluginInfo.

Host types

Host, HostsListPage, HostAgentInfo, HostGroup, HostKubernetesLabels, HostFromRelationships, HostToRelationships, AgentPotentialProblem(sState), ModuleInstance, PluginInstance, TechnologyInfo.

RUM / user-session types

ManualApplication, ConfiguredVersions, UserSession, UserSessionUserAction, UserSessionEvents, UserSessionErrors, UserSessionSyntheticEvent, UsqlResultAsTable, UsqlResultAsTree, KeyPerformanceMetrics.

Synthetic types

SyntheticMonitor(Update), BrowserSyntheticMonitor(Update), HttpSyntheticMonitor(Update), Monitors, MonitorCollectionElement, Node(s), NodeCollectionElement, OutageHandlingPolicy, GlobalOutagePolicy, LocalOutagePolicy, LoadingTimeThreshold(sPolicyDto).

Common / property types

ClusterId, ClusterVersion, ManagementZone, TagInfo, TagWithSourceInfo, EntityIdDto, EntityShortRepresentation, EventDto, Error, ErrorEnvelope, ConstraintViolation, and property wrappers (StringProperty, LongProperty, DoubleProperty, DateProperty, SectionProperty).

Enums

All enums in this SDK are deprecated in favor of literal string values.

Mostly installer download discriminators (OS type, architecture, bitness, flavor, installer type, orchestration type) and host query filters (GetHostsWithSpecificAgentsQuery*), plus host attribute enums (HostOsType, HostCloudType, HostMonitoringMode, HostBitness, …), synthetic monitor enums (SyntheticMonitorType, …), and user-session enums (UserSessionUserType, UserSessionUserActionType, …). See the canonical enums page for the full list.

Access-token clients

Manage API tokens, ActiveGate tokens, agent tokens, and tenant token rotation. Import from @dynatrace-sdk/client-classic-environment-v2.

accessTokensApiTokensClient

accessTokensActiveGateTokensClient

accessTokensAgentTokensClient

accessTokensTenantTokensClient

ActiveGate clients

Inspect ActiveGates, groups, and manage auto-update config/jobs. Import from @dynatrace-sdk/client-classic-environment-v2.

activeGatesClient

activeGatesActiveGateGroupsClient

activeGatesAutoUpdateConfigurationClient

activeGatesAutoUpdateJobsClient

auditLogsClient

Read the environment activity/audit log. Import:

import { auditLogsClient } from "@dynatrace-sdk/client-classic-environment-v2";

credentialVaultClient

Stored credentials (certificates, tokens, username/password) — commonly used to authenticate external fetch calls. Import:

import { credentialVaultClient } from "@dynatrace-sdk/client-classic-environment-v2";

Scopes: credential-vault read/write scopes (see canonical page per method).

Example — credential vault for external fetch

import { credentialVaultClient } from "@dynatrace-sdk/client-classic-environment-v2";

const creds = await credentialVaultClient.getCredentialsDetails({ id: "CREDENTIALS_VAULT-..." });
const auth = `Basic ${btoa(`${creds.username}:${creds.password}`)}`;
const res = await fetch("https://api.example.com/...", { headers: { Authorization: auth } });

See ../../fetch.md for the full external-fetch pattern.

Monitored-entities clients

Query monitored entities, manage custom tags and monitoring state. Import from @dynatrace-sdk/client-classic-environment-v2.

monitoredEntitiesClient

monitoredEntitiesCustomTagsClient

monitoredEntitiesMonitoringStateClient

Events clients

Custom events and business-event ingestion. Import from @dynatrace-sdk/client-classic-environment-v2.

eventsClient

businessEventsClient

Example

import { businessEventsClient } from "@dynatrace-sdk/client-classic-environment-v2";

await businessEventsClient.ingest({ body: { /* CloudEvent(s) */ }, type: "application/cloudevent+json" });

extensions_2_0Client

Manage Extensions 2.0 — extension lifecycle, monitoring configurations, schemas. Import:

import { extensions_2_0Client } from "@dynatrace-sdk/client-classic-environment-v2";

Extension lifecycle

Monitoring configurations

Environment configuration & schemas

logsClient

Classic log records API (prefer DQL via client-query for new code). Import:

import { logsClient } from "@dynatrace-sdk/client-classic-environment-v2";

Metrics clients

Classic metrics query/ingest and unit conversion. Import from @dynatrace-sdk/client-classic-environment-v2.

metricsClient

metricsUnitsClient

networkZonesClient

Manage network zones. Import:

import { networkZonesClient } from "@dynatrace-sdk/client-classic-environment-v2";

problemsClient

Query problems and manage problem comments. Import:

import { problemsClient } from "@dynatrace-sdk/client-classic-environment-v2";

Classic Environment v2 (@dynatrace-sdk/client-classic-environment-v2)

Env: ✅ Server runtime

Status: current (supersedes v1 — see classic-environment-v1 for not-yet-migrated resources)

Client for the Dynatrace Environment API v2: settings, tokens, ActiveGates, events, audit logs, and the credential vault.

Clients & key methods

Full detail by domain (34 clients)

This SDK exposes 34 clients, grouped by domain into the files below (each client is its own section). Exact per-method OAuth scopes are on the canonical page; the general pattern is <area>:<resource>:read|write (e.g. settings:objects:read, credential-vault scopes, entities:read, metrics:read/:write, events:ingest, slo:read/:write, securityProblems:read).

Required scopes

• Per-operation, e.g. settings:objects:read / settings:objects:write, environment:roles:manage-settings, credential-vault scopes. Each method's docs list the exact scope.

Example — credential vault for an external fetch

import { credentialVaultClient } from "@dynatrace-sdk/client-classic-environment-v2";

const creds = await credentialVaultClient.getCredentialsDetails({ id: "CREDENTIALS_VAULT-..." });
const auth = `Basic ${btoa(`${creds.username}:${creds.password}`)}`;

See fetch.md for the full external-fetch pattern.

Notes — settingsObjectsClient pagination gotcha

When a response has a nextPageKey, pass it as the sole parameter — omit schemaIds, fields, pageSize, and everything else. Mixing nextPageKey with any other param causes 400: Constraints violated.

const items = [];
let nextPageKey;
do {
  const page = await settingsObjectsClient.getSettingsObjects(
    nextPageKey
      ? { nextPageKey }
      : { schemaIds: "builtin:my-schema", fields: "scope,value", pageSize: 500 }
  );
  items.push(...(page.items ?? []));
  nextPageKey = page.nextPageKey;
} while (nextPageKey);

The spread trick { schemaIds: "...", ...(nextPageKey ? { nextPageKey } : {}) } looks equivalent but sends both params on page 2 — the API rejects it. The same rule applies to other paginated settings clients (e.g. app-settings).

• Business-event ingestion: 5 MiB max payload per request.
• Early-adopter/preview operations may change incompatibly; new enum values may appear without a version bump — handle unknown values gracefully.

Canonical reference: https://developer.dynatrace.com/develop/sdks/client-classic-environment-v2/

Releases & RUM clients

Import from @dynatrace-sdk/client-classic-environment-v2.

releasesClient

rumManualInsertionTagsClient

Generate RUM JavaScript tags for manual insertion.

Security clients

Security problems, attacks, and Davis security advice. Import from @dynatrace-sdk/client-classic-environment-v2.

securityProblemsClient

attacksClient

davisSecurityAdvisorClient

Settings clients

Settings objects, schemas, and management zones. Import from @dynatrace-sdk/client-classic-environment-v2.

settingsObjectsClient

Common scopes: settings:objects:read / settings:objects:write, plus settings:objects:admin for some permission ops.

Pagination gotcha

const items = [];
let nextPageKey;
do {
  const page = await settingsObjectsClient.getSettingsObjects(
    nextPageKey
      ? { nextPageKey }                                              // sole param!
      : { schemaIds: "builtin:my-schema", fields: "scope,value", pageSize: 500 }
  );
  items.push(...(page.items ?? []));
  nextPageKey = page.nextPageKey;
} while (nextPageKey);

Passing nextPageKey alongside schemaIds/fields/pageSize on page 2 returns 400: Constraints violated.

settingsSchemasClient

settingsManagementZonesClient

serviceLevelObjectivesClient

Manage Service-Level Objectives (SLOs). Import:

import { serviceLevelObjectivesClient } from "@dynatrace-sdk/client-classic-environment-v2";

Synthetic clients

Synthetic locations/nodes, network-availability monitors, and on-demand/HTTP executions. Import from @dynatrace-sdk/client-classic-environment-v2.

syntheticLocationsNodesAndConfigurationClient

syntheticNetworkAvailabilityMonitorsClient

syntheticOnDemandMonitorExecutionsClient

syntheticHttpMonitorExecutionsClient

Classic Environment v2 — Types & Enums

This SDK has a very large type/enum surface (hundreds of exports). Rather than duplicate it all, this file groups the type families; for exact field definitions use the canonical reference:

Full types: https://developer.dynatrace.com/develop/sdks/client-classic-environment-v2/#types Full enums: https://developer.dynatrace.com/develop/sdks/client-classic-environment-v2/#enums

Type families (by domain)

• Access tokens — ApiToken, ApiTokenCreate, ApiTokenCreated, ApiTokenList, ApiTokenSecret, ApiTokenUpdate, ActiveGateToken*, AgentConnectionToken, TenantToken*.
• ActiveGates — ActiveGate, ActiveGateList, ActiveGateGroup(s), ActiveGateAutoUpdateConfig, ActiveGateGlobalAutoUpdateConfig, UpdateJob, UpdateJobList.
• Credential vault — Credentials, CredentialsList, CredentialsResponseElement, CredentialsDetailsList, *Credentials (AWS/Azure/Hashicorp/CyberArk/Certificate/Token/UserPassword/SNMPV3), ExternalVault(Config).
• Settings — SettingsObject, SettingsObjectCreate, SettingsObjectUpdate, SettingsObjectResponse, ObjectsList, EffectiveSettingsValue(sList), SchemaDefinitionRestDto*, SchemaStub, AccessorPermissions(List), EffectivePermission, TransferOwnershipRequest.
• Events — Event, EventList, EventIngest, EventIngestResult(s), EventType(List), EventProperty, CloudEvent, BizEventIngestResult.
• Metrics — MetricDescriptor(Collection), MetricData, MetricSeries(Collection), MetricDto, Unit, UnitList, UnitConversionResult.
• Entities — Entity, EntitiesList, EntityType(List), EntityId, CustomDeviceCreation, METag, AddEntityTag(s), MonitoredEntityStates.
• Problems — Problem, Problems, Comment, CommentsList, ProblemCloseResult.
• Security — SecurityProblem(List/Details), Attack(List), RemediationItem(List), RiskAssessment*, Vulnerability, VulnerableFunction(s), DavisSecurityAdvice(List).
• Synthetic — SyntheticLocation(s), PrivateSyntheticLocation, Node(s), SyntheticBrowserMonitor*, SyntheticMultiProtocolMonitor*, SyntheticOnDemand*, monitor step/config DTOs.
• SLO — SLO, SLOs, SloBurnRate(Config), BurnRateAlert, StatusAlert.
• Network zones — NetworkZone(List), NetworkZoneSettings, NetworkZoneConnectionStatistics.
• Extensions — Extension(List/Info), ExtensionMonitoringConfiguration(sList), MonitoringConfigurationDto, SchemaFiles, ExtensionEventDto, UI customization DTOs (Ui*Customization).
• Audit / releases / RUM — AuditLog(Entry), Release(s), ReleaseInstance, JavaScriptAgentSettingsDto.
• Errors / common — Error, ErrorEnvelope, ConstraintViolation, ConfigurationMetadata, ModificationInfo, Success(Envelope).

Enums

Hundreds of enums exist, mostly query-parameter and status discriminators (e.g. ProblemStatus, ProblemSeverityLevel, SecurityProblemStatus, AttackState, SLOStatus, ApiTokenScopesItem, ActiveGateType, MetricValueTypeType, SyntheticLocationStatus, AuditLogEntryEventType). See the canonical enums page linked above for the full list and values.

analyzersClient

Run Davis predictive/causal analyzers. Import:

import { analyzersClient } from "@dynatrace-sdk/client-davis-analyzers";

Example — execute + poll

import { analyzersClient } from "@dynatrace-sdk/client-davis-analyzers";

const res = await analyzersClient.executeAnalyzer({
  analyzerName: "dt.statistics.GenericForecastAnalyzer",
  body: { timeSeriesData: { expression: "timeseries avg(dt.host.cpu.usage)" }, forecastHorizon: 10 },
});
let r = res;
while (r.result?.executionStatus === "RUNNING" && r.requestToken) {
  r = await analyzersClient.pollAnalyzerExecution({ analyzerName: "...", requestToken: r.requestToken });
}

Davis AI Analyzers (@dynatrace-sdk/client-davis-analyzers)

Env: ✅ Server runtime

Status: current

Run Davis predictive and causal AI analyzers for custom ML analysis.

Concepts

• Async execution: executeAnalyzer runs asynchronously. If a result isn't ready within the requested timeout it returns a requestToken; otherwise the final result is returned directly. Poll with pollAnalyzerExecution while executionStatus === "RUNNING"; cancel with cancelAnalyzerExecution. Results have a TTL.
• Self-describing: input/result JSON schemas and per-analyzer Markdown documentation are retrievable.
• Naming: "Davis AI" naming persists in APIs despite the "Dynatrace Intelligence" rebrand.

Clients & key methods

Full method/type detail: analyzersClient.md (per-method returns, scopes, examples) · types.md (types + enums).

Required scopes

• davis:analyzers:read (discovery/schemas), davis:analyzers:execute (validate/execute/poll/cancel). Some analyzers need extra scopes to read Grail data, e.g. storage:buckets:read, storage:metrics:read.

Example

import { analyzersClient } from "@dynatrace-sdk/client-davis-analyzers";

const res = await analyzersClient.executeAnalyzer({ analyzerName: "...", body: { /* input */ } });
// poll with res.requestToken if not immediately SUCCEEDED

Canonical reference: https://developer.dynatrace.com/develop/sdks/client-davis-analyzers/

Davis Analyzers — Types & Enums

Full field definitions: https://developer.dynatrace.com/develop/sdks/client-davis-analyzers/#types

Definition / discovery types

AnalyzerDefinition, AnalyzerDefinitionDetails, AnalyzerData, AnalyzerDimensionalData, AnalyzerCategory, AnalyzerQueryResult, AnalyzerGeneralParameters, ParameterDefinition, EnumerationElement, DimensionQuery, Timeframe.

Execution types

AnalyzerInput, AnalyzerExecuteResult, AnalyzerPollResult, AnalyzerCancelResult, AnalyzerValidationResult, AnalyzerResult, AnalyzerOutput, AnalyzerOutputSystemParameters, AnalyzerExecutionLog, AnalyzerOutputLog.

Error types

AnalyzerError, AnalyzerErrorDetails, AnalyzerErrorEnvelope, ConstraintViolation.

Enums

AnalyzerDefinitionType, AnalyzerDimensionalDataType, AnalyzerExecutionLogLevel, AnalyzerOutputLogLevel, AnalyzerResultExecutionStatus, AnalyzerResultResultStatus, JsonSchemaConfig, ParameterDefinitionType.

directSharesClient

Direct-shares immediately grant read or read-write access to specific SSO users/groups. Import:

import { directSharesClient } from "@dynatrace-sdk/client-document";

All methods accept optional admin-access (requires document:documents:admin).

Example

import { directSharesClient } from "@dynatrace-sdk/client-document";

const data = await directSharesClient.createDirectShare({
  body: {
    documentId: "...",
    access: "read-write",
    recipients: [{ id: "441664f0-23c9-40ef-b344-18c02c23d789", type: "group" }],
  },
});

documentLockingClient

Optional active locking to prevent concurrent-update conflicts. Import:

import { documentLockingClient } from "@dynatrace-sdk/client-document";

Example

import { documentLockingClient } from "@dynatrace-sdk/client-document";

const data = await documentLockingClient.acquireLock({
  id: "...",
  body: { documentVersion: 10 },
});

documentsClient

Core document lifecycle: create, read, update, delete, content, snapshots, ownership. Import:

import { documentsClient } from "@dynatrace-sdk/client-document";

All methods accept optional admin-access (requires document:documents:admin).

listDocuments filter/sort

• Filterable fields: id, name, type, version, owner, modificationInfo.{createdTime,createdBy,lastModifiedTime,lastModifiedBy}, originAppId, originExtensionId. Operators contains/starts-with/ends-with are case-insensitive (string fields); ==/!= are case-sensitive equality operators. String literals must use single quotes. Max nesting depth 3, max length 1024 chars. Example: type in ('dashboard', 'notebook') and name contains 'report'.
• Sortable fields: name, type, version, owner, modificationInfo.*, originAppId, userContext.lastAccessedTime. Max 5 sort params. Default sort: by id. Example: name,-type,modificationInfo.lastModifiedTime.
• Pagination is naive — interim mutations can yield duplicates/missing entries.

Example

import { documentsClient } from "@dynatrace-sdk/client-document";

const data = await documentsClient.createDocument({
  body: { name: "...", type: "...", content: "..." },
});

environmentSharesClient

Environment-shares grant claimable read/read-write access to same-environment users. Import:

import { environmentSharesClient } from "@dynatrace-sdk/client-document";

All methods accept optional admin-access (requires document:documents:admin).

Example

import { environmentSharesClient } from "@dynatrace-sdk/client-document";

const data = await environmentSharesClient.createEnvironmentShare({
  body: { documentId: "...", access: "read" },
});

Document (@dynatrace-sdk/client-document)

Env: ✅ Server runtime

Status: current

Create, manage, and share documents (dashboards, notebooks, launchpads). Documents are schemaless and hold up to 50 MB of content.

Clients & key methods

Full method/type detail: documentsClient.md, directSharesClient.md, environmentSharesClient.md, documentLockingClient.md, trashClient.md (per-method returns, scopes, examples) · types.md.

Required scopes

• document:documents:read / document:documents:write (plus share/trash scopes as needed).

Example

import { documentsClient } from "@dynatrace-sdk/client-document";

const doc = await documentsClient.createDocument({
  body: { name: "Report", type: "dashboard", content: "..." },
});

Concepts

• Access management — two layers: IAM endpoint permissions (e.g. document:documents:read, not modifiable via API) and per-document document permissions (modeled in the service, modifiable via sharing endpoints). A user needs both.
• Sharing — three mechanisms, not mutually exclusive:
• Public — via updateDocument (isPrivate: false); grants read to all environment users immediately.
• Environment-shares — grant read or read-write to same-environment users, but users must actively claim the share; owner loses control over who claims.
• Direct-shares — immediately grant read/read-write to specific users/groups; owner keeps full control and can revoke. Max one direct-share per access type per document; up to 1000 recipients.
• Set isReshareable: false (via updateDocument) to stop write-access users from re-sharing.
• Owner transfer — transferDocumentOwner; previous owner loses access.
• Locking:
• Optimistic locking (mandatory) — modifying ops require the current document version; mismatch ⇒ rejected.
• Active locking (optional) — lock a document to block other users' updates. Max 5 locked docs per user; lock duration max 15 min (default 10); re-acquiring extends.
• Deletion & restoration — deletes move to trash, permanently removed after 30 days; restore re-grants prior access.
• Snapshots — reset content to an earlier state. Created explicitly on update; max 50 per document (oldest auto-deleted), rate-limited 5 per 60 s, auto-deleted after 30 days. Read with doc read access; create with write access; restore/delete owner-only.
• Document identity — unique immutable id assigned at creation; may be user-supplied, else system-generated.
• Admin access — document:documents:admin lets a user act on all environment documents regardless of ownership; enabled per-request via the admin-access parameter (not supported for ready-made documents).
• User data — no names/emails stored; SSO ids are persisted. Last-access per document is tracked for ordering.
• System-owned / ready-made / extension-shipped documents — some documents are system-, app- (originAppId), or extension-owned (originExtensionId) and auto-available on install/update.
• Content size — max 50 MB per document.

Canonical reference: https://developer.dynatrace.com/develop/sdks/client-document/ · npm @dynatrace-sdk/client-document (v1.30.0).

trashClient

Manage deleted documents (trash). Deleted documents are permanently destroyed after 30 days. Import:

import { trashClient } from "@dynatrace-sdk/client-document";

All methods accept optional admin-access (requires document:documents:admin).

Example

import { trashClient } from "@dynatrace-sdk/client-document";

const data = await trashClient.restoreTrashedDocument({ id: "..." });

Document — Types

All exported types of @dynatrace-sdk/client-document. Full field definitions: https://developer.dynatrace.com/develop/sdks/client-document/#types

Request / body types

AcquireLock, AddDirectShareRecipients, BulkDeleteRequest, CreateDirectShare, CreateDocumentBody, CreateEnvShare, RemoveDirectShareRecipients, TransferOwner, UpdateDocumentBody, UpdateDocumentContentBody, UpdateDocumentMetadataBody.

Response / result types

AcquireLockResult, BulkDeleteResponse, BulkDeleteResponseDocumentsItem, CreatedSnapshot, DirectShare, DirectShareList, DirectShareRecipientList, DocumentList, DocumentLockDetails, DocumentMetaData, EnvironmentShare, EnvironmentShareClaimResult, EnvironmentShareClaimerList, EnvironmentShareList, GetDocumentResponse, RestoreDocumentResult, SnapshotList, SnapshotMetadata, TrashDocument, TrashDocumentList, TrashDocumentListEntry, UpdateDocumentMetadata.

Shared / sub types

CreationInfo, DeletionInfo, ModificationInfo, ShareInfo, SsoEntity, UserContext.

Error types

Error, ErrorDetails, ErrorEnvelope.

edgeConnectClient

Manage EdgeConnect configurations. Import:

import { edgeConnectClient } from "@dynatrace-sdk/client-app-engine-edge-connect";

Example

import { edgeConnectClient } from "@dynatrace-sdk/client-app-engine-edge-connect";

const ec = await edgeConnectClient.createEdgeConnect({
  body: { name: { value: "my-edge" }, hostPatterns: ["*.internal.org"] },
});

AppEngine EdgeConnect (@dynatrace-sdk/client-app-engine-edge-connect)

Env: ✅ Server runtime

Status: current

Manage EdgeConnect configurations, which forward HTTP requests from the runtime to resources in private networks.

Clients & key methods

Full method/type detail: edgeConnectClient.md (per-method returns, scopes, examples) · types.md (types + enums).

Required scopes

• app-engine:edge-connects:write (and oauth2:clients:manage for auto-generated OAuth client deletion).

Notes

• An EdgeConnect config defines which HTTP requests (by host pattern) are forwarded to and executed by an EdgeConnect in a private network. Host patterns support wildcards (e.g. *.internal.org).
• Names must be ≤ 50 chars and RFC 1123 compliant.
• OAuth client secrets are returned only at creation — they cannot be retrieved later.
• Autogenerated OAuth clients: if no client ID is provided on create, one is autogenerated, which additionally requires oauth2:clients:manage for the app-engine:edge-connects:connect scope (e.g. ALLOW oauth2:clients:manage where oauth2:scopes='app-engine:edge-connects:connect'). Deleting a config with an autogenerated client needs the same scope.

Canonical reference: https://developer.dynatrace.com/develop/sdks/client-app-engine-edge-connect/

EdgeConnect — Types & Enums

Full field definitions: https://developer.dynatrace.com/develop/sdks/client-app-engine-edge-connect/#types

Config types

EdgeConnect, EdgeConnectInstance, EdgeConnects, HostMapping, Metadata, ModificationInfo, OAuthClientRotationResponse.

Matching types

MatchedEdgeConnect, MatchedResponse.

Error types

Error, ErrorDetails, ErrorResponse, ConstraintViolation.

Enums

• MetadataOauthClientStatus — OAuth client status values in Metadata.

filterSegmentsClient

Manage Grail filter-segments. Import:

import { filterSegmentsClient } from "@dynatrace-sdk/client-filter-segment-management";

Example

import { filterSegmentsClient } from "@dynatrace-sdk/client-filter-segment-management";

const seg = await filterSegmentsClient.createFilterSegment({
  body: {
    name: "dev_environment",
    isPublic: false,
    variables: { type: "query", value: "fetch logs | limit 1" },
    includes: [{ filter: "...", dataObject: "logs" }],
  },
});

Grail Filter-Segments (@dynatrace-sdk/client-filter-segment-management)

Env: ✅ Server runtime

Status: current

Create and manage filter-segments that slice and contextualize Grail data.

Clients & key methods

Full method/type detail: filterSegmentsClient.md (per-method returns, scopes, examples) · types.md (types + enums).

Required scopes

• storage:filter-segments:read / :write / :delete / :share (sharing a public segment requires :share).

Example

import { filterSegmentsClient } from "@dynatrace-sdk/client-filter-segment-management";

const data = await filterSegmentsClient.createFilterSegment({
  body: {
    name: "dev_environment",
    isPublic: false,
    includes: [{ filter: "...", dataObject: "logs" }],
  },
});

Notes

• A filter-segment scopes/contextualizes Grail data via includes (per-dataObject filters) and optional variables.
• Visibility: isPublic false = private to owner; true = visible to everyone in the environment (requires storage:filter-segments:share).
• Use getLeanFilterSegments for faster, minimal responses when details aren't needed.
• Optimistic locking via version on updates.
• Filter syntax requires quoting special field names.

Canonical reference: https://developer.dynatrace.com/develop/sdks/client-filter-segment-management/

Filter-Segments — Types & Enums

Full field definitions: https://developer.dynatrace.com/develop/sdks/client-filter-segment-management/#types

Segment types

FilterSegment, FilterSegments, DetailedFilterSegment, LeanFilterSegment, LeanFilterSegments, NewFilterSegment, UpdateFilterSegment, PartialUpdateFilterSegment, FilterSegmentVariables, Include, NewInclude, Relationship, NewRelationship.

Entity-model types

FilterSegmentNamespaceDto, FilterSegmentPropertyDto, FilterSegmentPushDownFilterableDto, FilterSegmentRelationshipDto, FilterSegmentTypeDto.

Error types

ErrorEnvelope, ErrorInfo, ExceptionalReturn, CustomValidationErrorInfo, InvalidAuditEventsErrorInfo, MediaTypeErrorInfo, ParameterErrorInfo, ProxyErrorInfo, QueryFrontendRawErrorInfo, RequestBodyErrorInfo.

Enums

DetailedFilterSegmentAllowedOperationsItem, FilterSegmentAllowedOperationsItem, LeanFilterSegmentAllowedOperationsItem, GetFilterSegmentQueryAddFieldsItem, GetFilterSegmentsQueryAddFieldsItem, GetLeanFilterSegmentsQueryAddFieldsItem.

appsClient

Browse Hub apps. All methods require scope hub:catalog:read. Import:

import { appsClient } from "@dynatrace-sdk/client-hub";

Example

import { appsClient } from "@dynatrace-sdk/client-hub";

const apps = await appsClient.getAppOverviewList();
const detail = await appsClient.getAppDetails({ id: "..." });

categoriesClient

Browse Hub categories. Requires scope hub:catalog:read. Import:

import { categoriesClient } from "@dynatrace-sdk/client-hub";

Example

import { categoriesClient } from "@dynatrace-sdk/client-hub";

const categories = await categoriesClient.getCategories();

extensionsClient

Browse Hub extensions. All methods require scope hub:catalog:read. Import:

import { extensionsClient } from "@dynatrace-sdk/client-hub";

Example

import { extensionsClient } from "@dynatrace-sdk/client-hub";

const detail = await extensionsClient.getExtensionDetails({ id: "..." });

Hub (@dynatrace-sdk/client-hub)

Env: ✅ Server runtime

Status: current

Read the Dynatrace Hub catalog — apps, extensions, and technologies for the environment.

Clients & key methods

Full method/type detail: appsClient.md, extensionsClient.md, technologiesClient.md, categoriesClient.md (per-method returns, scopes, examples) · types.md (types + enums).

Required scopes

• hub:catalog:read.

Example

import { appsClient } from "@dynatrace-sdk/client-hub";

const data = await appsClient.getAppDetails({ id: "..." });

Notes

• Supports filtering to exclude incompatible instances.

Canonical reference: https://developer.dynatrace.com/develop/sdks/client-hub/

technologiesClient

Browse Hub technologies. All methods require scope hub:catalog:read. Import:

import { technologiesClient } from "@dynatrace-sdk/client-hub";

Example

import { technologiesClient } from "@dynatrace-sdk/client-hub";

const tech = await technologiesClient.getTechnologyDetails({ id: "..." });

Hub — Types & Enums

Full field definitions: https://developer.dynatrace.com/develop/sdks/client-hub/#types

Overview / detail / release types

OverviewsList, Detail, DetailSection, MarkdownSection, GallerySection, GalleryImage, GalleryImageResolutions, Release, ReleasesList, Manifest, ManifestScope, ExtensionMetadata, Link, Author, Dependency, AssetCount, ContentCount, DocumentCount, DocumentCountTypes, Revocation, ResourceContext.

Category types

Categories, Category, CategoryPage, CategoryPageContent, CategoryPageContentBlock.

Error types

Error, ErrorDetails, ErrorEnvelope, ConstraintViolation.

Enums

CategoryPageContentContentType, Compatibility, ItemType, LinkType, RevocationReason, RevocationSeverity, ResourceContextOperationsItem, and the optional-field enums (OptionalAppDetailField, OptionalAppOverviewField, OptionalAppReleaseField, OptionalExtensionDetailField, OptionalExtensionReleaseField, OptionalOverviewField, OptionalTechnologyDetailField).

Identity & Access Management (@dynatrace-sdk/client-iam)

Env: ✅ Server runtime

Status: current

Query users, groups, and service users across organizational levels.

Clients & key methods

Types: RestUserPublic, RestGroupPublic, ServiceUserDto; responses include pagination (nextPageKey, totalCount).

Full method/type detail: usersAndGroupsClient.md (per-method returns, scopes, examples) · types.md (types + enums).

Concepts

• Queries are scoped to an organizational level via levelType + levelId (e.g. account or environment). Authorization is based on the calling user's assignment to the account associated with that level; for environment level the user must be assigned to the account the environment belongs to (no explicit env permissions needed).
• Read-only SDK — view users/groups/service users; no user/group mutation here.

Required scopes

• iam:users:read / iam:groups:read.

Notes

• Filter strings: min 3, max 320 chars.
• Throttling applies; responses include retry information.

Canonical reference: https://developer.dynatrace.com/develop/sdks/client-iam/

IAM — Types & Enums

Full field definitions: https://developer.dynatrace.com/develop/sdks/client-iam/#types

User / group / service-user types

RestUserPublic, RestUserPublicListResponse, RestGroupPublic, RestGroupPublicListResponse, ServiceUserDto, SearchResult.

Error types

ErrorResponse, ErrorResponseConstraintViolation, ErrorResponseDetails, ErrorThrottlingResponse, PublicExceptionMessage, PublicExceptionThrottlingMessage.

Enums

• RestGroupPublicType — group type values.

usersAndGroupsClient

Query users, groups, and service users at an organizational level. Import:

import { usersAndGroupsClient } from "@dynatrace-sdk/client-iam";

Example

import { usersAndGroupsClient } from "@dynatrace-sdk/client-iam";

const users = await usersAndGroupsClient.getActiveUsersForOrganizationalLevel({
  levelType: "account",
  levelId: "...",
  partialString: "jane",
});

Navigation — Functions

⚠️ BROWSER-ONLY — frontend (React) use only; no effect in the server-side JS runtime.

Import from @dynatrace-sdk/navigation.

Notes

• App/document availability varies across environments — links aren't guaranteed to resolve.
• To receive intents, declare them in the app manifest and add an /intent/:intentId route — see receiving intents.

Navigation (@dynatrace-sdk/navigation)

Env: ⚠️ BROWSER-ONLY — do NOT use in server-side JS runtime functions.

Status: current

This SDK drives navigation within the browser app shell (opening apps/documents, sending intents between apps). It depends on the browser runtime and has no effect in the server-side JS runtime. Use it only in app frontend (React) code.

Key exports (frontend use only)

getAppLink / openApp, getDocumentLink / openDocument, sendIntent / sendIntentWithResponse, getIntent, getIntentLink, setPathChangeHandler.

Full detail: functions.md (per-function signatures + examples) · types.md (Intent, IntentPayload, IntentResponseOkEnvelope, IntentResponseErrorEnvelope).

Notes

• Page tokens are app-manifest identifiers used as a public navigation API (distinct from URL routes) — see registering page tokens.
• Don't hardcode app IDs — availability isn't guaranteed across platform instances.

Canonical reference: https://developer.dynatrace.com/develop/sdks/navigation/

Navigation — Types

⚠️ BROWSER-ONLY SDK.

Full field definitions: https://developer.dynatrace.com/develop/sdks/navigation/#types

Notification v1 (@dynatrace-sdk/client-notification)

Env: ✅ Server runtime

Status: ⚠ DEPRECATED — use notification-v2 instead

Manage self-notifications via the Notification Service API. All methods are deprecated; migrate to v2.

Clients & key methods

selfNotificationsClient — createSelfNotification, getSelfNotification, getSelfNotifications, updateSelfNotification, patchSelfNotification, deleteSelfNotification.

Trigger types: event query, Davis problem, Davis event.

Full method/type detail: selfNotificationsClient.md · types.md.

Required scopes

• notification:self-notifications:read / notification:self-notifications:write.

Canonical reference: https://developer.dynatrace.com/develop/sdks/client-notification/

selfNotificationsClient

DEPRECATED — migrate to notification-v2.

Manage self-notifications. Import:

import { selfNotificationsClient } from "@dynatrace-sdk/client-notification";

Notification v1 — Types & Enums

DEPRECATED SDK. Full field definitions: https://developer.dynatrace.com/develop/sdks/client-notification/#types

Notification types

SelfNotification, SelfNotificationCreate, SelfNotificationInput, SelfNotificationUpdate, PaginatedSelfNotificationList, ModificationInfo.

Trigger-config types

DavisEventConfig, DavisEventName, DavisEventTriggerConfig, DavisProblemCategories, DavisProblemConfig, DavisProblemTriggerConfig, EventQuery, EventQueryTriggerConfig, EventTriggerConfig, EntityTags.

Error types

Error, ErrorDetails, ErrorEnvelope.

Enums

EventType, DavisEventNameMatch, DavisEventTriggerConfigType, DavisProblemTriggerConfigType, EntityTagsMatch, EventQueryTriggerConfigType, MaintenanceWindowTriggerBehaviorType.

eventNotificationsClient

Manage event-triggered notifications. Import:

import { eventNotificationsClient } from "@dynatrace-sdk/client-notification-v2";

Example

import { eventNotificationsClient } from "@dynatrace-sdk/client-notification-v2";

await eventNotificationsClient.createEventNotification({
  body: {
    resourceId: "...",
    notificationType: "...",
    triggerConfiguration: { type: "event", value: { query: "..." } },
  },
});

Notification v2 (@dynatrace-sdk/client-notification-v2)

Env: ✅ Server runtime

Status: current (replaces notification-v1)

Manage resource and event notifications via the Notification Service API.

Clients & key methods

EventTriggerConfig supports three trigger types: DQL EventQuery (EventQueryTriggerConfig), Davis problem (DavisProblemTriggerConfig), Davis event (DavisEventTriggerConfig).

Full method/type detail: eventNotificationsClient.md, resourceNotificationsClient.md (per-method returns, scopes, examples) · types.md (types + enums).

Required scopes

• notification:notifications:read / notification:notifications:write.

Example

import { eventNotificationsClient } from "@dynatrace-sdk/client-notification-v2";

const data = await eventNotificationsClient.createEventNotification({
  body: {
    resourceId: "...",
    notificationType: "...",
    triggerConfiguration: { type: "event", value: { query: "..." } },
  },
});

Canonical reference: https://developer.dynatrace.com/develop/sdks/client-notification-v2/

resourceNotificationsClient

Manage resource notifications. Import:

import { resourceNotificationsClient } from "@dynatrace-sdk/client-notification-v2";

Example

import { resourceNotificationsClient } from "@dynatrace-sdk/client-notification-v2";

await resourceNotificationsClient.createResourceNotification({
  body: { notificationType: "...", resourceId: "..." },
});

Notification v2 — Types & Enums

Full field definitions: https://developer.dynatrace.com/develop/sdks/client-notification-v2/#types

Notification types

EventNotification, EventNotificationInput, EventNotificationRequest, EventNotificationUpdate, PaginatedEventNotificationList, ResourceNotification, ResourceNotificationRequest, PaginatedResourceNotificationList, ModificationInfo.

Trigger-config types

DavisEventConfig, DavisEventName, DavisEventTriggerConfig, DavisProblemCategories, DavisProblemConfig, DavisProblemTriggerConfig, EventQuery, EventQueryTriggerConfig, EventTriggerConfig, EntityTags.

Error types

Error, ErrorDetails, ErrorEnvelope.

Enums

EventType, DavisEventNameMatch, DavisEventTriggerConfigType, DavisProblemTriggerConfigType, EntityTagsMatch, EventQueryTriggerConfigType.

effectivePermissionsClient

Import:

import { effectivePermissionsClient } from "@dynatrace-sdk/client-platform-management-service";

Example

import { effectivePermissionsClient } from "@dynatrace-sdk/client-platform-management-service";

const result = await effectivePermissionsClient.resolveEffectivePermissions({
  body: { /* ResolutionRequest */ },
});