@rnsk/toolkits 0.0.10 → 0.0.12

package/dist/toolkits/new-relic/tools/nrql-conditions.js

@@ -0,0 +1,136 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { accountIdField, nerdgraph, newRelicApiKeyField, restV2 } from './client.js';
+const signalInput = z.object({
+    aggregationWindow: z.number().int().min(30).describe('Aggregation window seconds (static: 30-120; baseline: 30-3600)'),
+    aggregationMethod: z.enum(['EVENT_FLOW', 'EVENT_TIMER', 'CADENCE']).describe('EVENT_FLOW recommended'),
+    aggregationDelay: z.number().int().min(0).max(1200).optional().describe('Delay seconds for late data (0-1200)'),
+}).describe('Signal aggregation config');
+const staticTerm = z.object({
+    threshold: z.number().describe('Threshold value triggering the alert'),
+    thresholdDuration: z.number().int().min(60).describe('Seconds violated before alerting (multiple of 60)'),
+    thresholdOccurrences: z.enum(['ALL', 'AT_LEAST_ONCE']).describe('ALL: every point violates; AT_LEAST_ONCE: one point'),
+    operator: z.enum(['ABOVE', 'ABOVE_OR_EQUALS', 'BELOW', 'BELOW_OR_EQUALS', 'EQUALS', 'NOT_EQUALS']),
+    priority: z.enum(['CRITICAL', 'WARNING']),
+});
+const CONDITION_SELECT = 'id name enabled';
+export const createStaticNrqlCondition = tool({
+    description: 'Creates a static NRQL alert condition (threshold-based) via NerdGraph. Find the policy ID via getAlertPolicies first.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID for the condition'),
+        policyId: z.string().describe('Policy ID to attach the condition to'),
+        name: z.string().describe('Condition name, unique within the policy'),
+        nrql: z.object({ query: z.string().describe("NRQL query, e.g. 'SELECT count(*) FROM Transaction'") }).describe('Query to monitor'),
+        signal: signalInput,
+        terms: staticTerm.describe('Threshold definition'),
+        valueFunction: z.enum(['SINGLE_VALUE', 'SUM']).describe('SINGLE_VALUE for scalars, SUM for aggregates'),
+        violationTimeLimitSeconds: z.number().int().min(300).max(2592000).describe('Max seconds a violation stays open (300-2592000)'),
+        enabled: z.boolean().optional().describe('Actively monitoring (default true)'),
+        description: z.string().optional(),
+        expiration: z.object({
+            expirationDuration: z.number().int().min(30).max(172800).optional(),
+            openViolationOnExpiration: z.boolean().optional().describe('Loss-of-signal detection'),
+            closeViolationsOnExpiration: z.boolean().optional(),
+        }).optional().describe('Signal-loss handling'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, policyId, ...condition }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $policyId: ID!, $condition: AlertsNrqlStaticConditionInput!) { alertsNrqlConditionStaticCreate(accountId: $accountId, policyId: $policyId, condition: $condition) { ${CONDITION_SELECT} } }`, { accountId, policyId, condition: { enabled: true, ...condition } }, 'create static NRQL condition'),
+});
+export const updateStaticNrqlCondition = tool({
+    description: 'Updates a static NRQL condition via NerdGraph. Only provided fields change; static-type conditions only.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID owning the condition'),
+        id: z.string().describe('Condition ID to update'),
+        condition: z.record(z.any()).describe("Fields to change: name, nrql {query}, signal, terms, valueFunction, enabled, description, expiration, etc."),
+    }),
+    execute: async ({ newRelicApiKey, accountId, id, condition }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $id: ID!, $condition: AlertsNrqlStaticConditionUpdateInput!) { alertsNrqlConditionStaticUpdate(accountId: $accountId, id: $id, condition: $condition) { ${CONDITION_SELECT} } }`, { accountId, id, condition }, 'update static NRQL condition'),
+});
+const baselineTerm = z.object({
+    threshold: z.number().describe('Standard deviations from baseline triggering the alert'),
+    thresholdDuration: z.number().int().min(60).max(7200).describe('Breach seconds before alerting (60-7200)'),
+    thresholdOccurrences: z.enum(['ALL', 'AT_LEAST_ONCE']),
+    operator: z.enum(['ABOVE', 'BELOW', 'EQUALS']),
+    priority: z.enum(['CRITICAL', 'WARNING']),
+});
+export const createNrqlBaselineCondition = tool({
+    description: 'Creates a NRQL baseline condition (ML anomaly detection vs historical baseline) via NerdGraph. Use for anomaly detection instead of static thresholds.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID for the condition'),
+        policyId: z.number().int().describe('Policy ID to attach the condition to'),
+        condition: z.object({
+            name: z.string().describe('Condition name'),
+            enabled: z.boolean().describe('Actively monitoring'),
+            baselineDirection: z.enum(['LOWER_ONLY', 'UPPER_ONLY', 'UPPER_AND_LOWER']).describe('Anomaly direction'),
+            nrql: z.object({ query: z.string().describe("NRQL query, e.g. 'SELECT average(duration) FROM Transaction'") }),
+            signal: signalInput,
+            terms: z.array(baselineTerm).min(1).describe('Threshold terms (at least one)'),
+            runbookUrl: z.string().optional(),
+            description: z.string().optional(),
+        }).describe('Baseline condition configuration'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, policyId, condition }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $policyId: ID!, $condition: AlertsNrqlBaselineConditionInput!) { alertsNrqlConditionBaselineCreate(accountId: $accountId, policyId: $policyId, condition: $condition) { ${CONDITION_SELECT} baselineDirection } }`, { accountId, policyId: String(policyId), condition }, 'create NRQL baseline condition'),
+});
+export const updateNrqlBaselineCondition = tool({
+    description: 'Updates a baseline NRQL condition via NerdGraph (name, direction, thresholds, query, etc.). Baseline-type only.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID owning the condition'),
+        id: z.string().describe('Baseline condition ID to update'),
+        condition: z.record(z.any()).describe('Fields to change: name, baselineDirection, nrql {query, dataAccountId}, terms, signal, expiration, enabled, etc.'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, id, condition }) => nerdgraph(newRelicApiKey, `mutation($accountId: Int!, $id: ID!, $condition: AlertsNrqlBaselineConditionUpdateInput!) { alertsNrqlConditionBaselineUpdate(accountId: $accountId, id: $id, condition: $condition) { ${CONDITION_SELECT} baselineDirection } }`, { accountId, id, condition }, 'update NRQL baseline condition'),
+});
+const restTerm = z.object({
+    duration: z.string().describe("Minutes as string, e.g. '5'"),
+    operator: z.enum(['above', 'below', 'equal']),
+    priority: z.enum(['critical', 'warning']),
+    threshold: z.string().describe("Numeric string, e.g. '100'"),
+    timeFunction: z.enum(['all', 'any']).describe('all: entire duration; any: at least once'),
+});
+export const createNrqlCondition = tool({
+    description: 'Creates a NRQL alert condition via REST API v2 for threshold alerting on custom queries.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        policyId: z.number().int().describe('Policy ID to add the condition to'),
+        nrqlCondition: z.object({
+            name: z.string().describe('Condition name, unique within the policy'),
+            enabled: z.boolean().describe('Active immediately'),
+            nrql: z.object({ query: z.string().describe("Valid NRQL SELECT, e.g. 'SELECT count(*) FROM Transaction'") }),
+            terms: z.array(restTerm).min(1).describe('Threshold terms (at least one)'),
+            type: z.enum(['static']).optional().describe("Condition type (default 'static')"),
+            runbookUrl: z.string().optional(),
+            valueFunction: z.string().optional().describe("e.g. 'single_value'"),
+        }).describe('NRQL condition configuration'),
+    }),
+    execute: async ({ newRelicApiKey, policyId, nrqlCondition }) => restV2(newRelicApiKey, 'POST', `/alerts_nrql_conditions/policies/${policyId}.json`, { body: { nrql_condition: { type: 'static', ...nrqlCondition } } }, 'create NRQL condition'),
+});
+export const updateNrqlCondition = tool({
+    description: 'Updates a NRQL condition (name, query, thresholds, enabled) via REST API v2. Only provided fields change.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        conditionId: z.number().int().describe('NRQL condition ID to update'),
+        nrqlCondition: z.record(z.any()).describe('Fields to change: name, nrql {query}, terms, enabled, runbook_url, value_function, etc.'),
+    }),
+    execute: async ({ newRelicApiKey, conditionId, nrqlCondition }) => restV2(newRelicApiKey, 'PUT', `/alerts_nrql_conditions/${conditionId}.json`, { body: { nrql_condition: nrqlCondition } }, 'update NRQL condition'),
+});
+export const deleteNrqlCondition = tool({
+    description: 'Deletes a NRQL alert condition via REST API v2 after confirming the condition ID.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        conditionId: z.number().int().describe('NRQL condition ID to delete'),
+    }),
+    execute: async ({ newRelicApiKey, conditionId }) => restV2(newRelicApiKey, 'DELETE', `/alerts_nrql_conditions/${conditionId}.json`, undefined, 'delete NRQL condition'),
+});
+export const listNrqlConditions = tool({
+    description: 'Lists NRQL conditions for a policy via REST API v2 (queries, thresholds, enabled state).',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        policyId: z.number().int().describe('Policy ID to list NRQL conditions for'),
+        page: z.number().int().min(1).optional().describe('Page number for large result sets'),
+    }),
+    execute: async ({ newRelicApiKey, policyId, page }) => restV2(newRelicApiKey, 'GET', '/alerts_nrql_conditions.json', { query: { policy_id: policyId, page } }, 'list NRQL conditions'),
+});
+//# sourceMappingURL=nrql-conditions.js.map

package/dist/toolkits/new-relic/tools/nrql.d.ts

@@ -0,0 +1,38 @@
+export declare const executeNrqlQuery: import("ai").Tool<{
+    query: string;
+    accountId: number;
+    timeout?: number | undefined;
+    newRelicApiKey?: string | undefined;
+    asyncExecution?: boolean | undefined;
+}, any>;
+export declare const queryError: import("ai").Tool<{
+    accountId: number;
+    nrqlQuery: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const queryExampleReadQuery: import("ai").Tool<{
+    query: string;
+    newRelicApiKey?: string | undefined;
+    variables?: Record<string, any> | undefined;
+}, any>;
+export declare const searchEntities: import("ai").Tool<{
+    query?: string | undefined;
+    type?: string | undefined;
+    domain?: string | undefined;
+    newRelicApiKey?: string | undefined;
+    infrastructureIntegrationType?: string | undefined;
+    cursor?: string | undefined;
+}, any>;
+export declare const fetchRulesCollection: import("ai").Tool<{
+    collectionId: string;
+    newRelicApiKey?: string | undefined;
+    cursor?: string | undefined;
+}, any>;
+export declare const fetchYourOrgId: import("ai").Tool<{
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const queryCloudProviders: import("ai").Tool<{
+    accountId: number;
+    newRelicApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=nrql.d.ts.map

package/dist/toolkits/new-relic/tools/nrql.js

@@ -0,0 +1,99 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { accountIdField, nerdgraph, newRelicApiKeyField } from './client.js';
+const NRQL_SELECT = 'results queryProgress { queryId completed retryAfter retryDeadline resultExpiration }';
+function nrqlQueryObject(accountId, nrql, timeout, asyncExecution) {
+    return `{
+  actor {
+    account(id: ${accountId}) {
+      nrql(query: ${JSON.stringify(nrql)}${timeout !== undefined ? `, timeout: ${timeout}` : ''}${asyncExecution ? ', async: true' : ''}) {
+        ${NRQL_SELECT}
+      }
+    }
+  }
+}`;
+}
+export const executeNrqlQuery = tool({
+    description: "Executes a NRQL query against telemetry data (transactions, logs, metrics, events). Use asyncExecution for queries over ~5s, then poll with the returned queryId via the same query string.",
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID whose data to query'),
+        query: z.string().describe("NRQL query, e.g. 'SELECT count(*) FROM Transaction SINCE 1 HOUR AGO'"),
+        timeout: z.number().int().min(1).max(600).optional().describe('Timeout seconds (default 5; up to 600 on Data Plus)'),
+        asyncExecution: z.boolean().optional().describe('Async mode for long queries — returns queryId to poll'),
+    }),
+    execute: async ({ newRelicApiKey, accountId, query, timeout, asyncExecution }) => nerdgraph(newRelicApiKey, `query { ${nrqlQueryObject(accountId, query, timeout, asyncExecution)} }`, undefined, 'execute NRQL query'),
+});
+export const queryError = tool({
+    description: 'Queries error data (TransactionError etc.) with a custom NRQL query. Use to analyze error counts, facet by error.message, or spot error patterns.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID to query error data from'),
+        nrqlQuery: z.string().describe("NRQL query, e.g. 'SELECT count(*) FROM TransactionError FACET error.message SINCE 24 HOURS AGO'"),
+    }),
+    execute: async ({ newRelicApiKey, accountId, nrqlQuery }) => nerdgraph(newRelicApiKey, `query { ${nrqlQueryObject(accountId, nrqlQuery)} }`, undefined, 'query error data'),
+});
+export const queryExampleReadQuery = tool({
+    description: 'Executes any raw GraphQL read query against NerdGraph. Use for data not covered by other tools; pass variables separately.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        query: z.string().describe("GraphQL query, e.g. '{ actor { user { name email } } }'"),
+        variables: z.record(z.any()).optional().describe('Query variables, e.g. {accountId: 123456}'),
+    }),
+    execute: async ({ newRelicApiKey, query, variables }) => nerdgraph(newRelicApiKey, query.startsWith('query') || query.startsWith('mutation') ? query : `query { ${query} }`, variables, 'execute GraphQL query'),
+});
+export const searchEntities = tool({
+    description: 'Searches New Relic entities by name/type/domain (up to 200 per page). Use to find GUIDs for tagging, workloads, or deployments. Provide raw query OR queryBuilder, not both.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        query: z.string().optional().describe("Search string, e.g. \"domain = 'APM' and type = 'APPLICATION'\""),
+        domain: z.string().optional().describe("Builder: domain filter, e.g. 'APM', 'BROWSER', 'SYNTH', 'INFRA'"),
+        type: z.string().optional().describe("Builder: entity type, e.g. 'APPLICATION', 'MONITOR', 'HOST'"),
+        infrastructureIntegrationType: z.string().optional().describe('Builder: infra integration type, e.g. AWS_RDS_DB_INSTANCE'),
+        cursor: z.string().optional().describe('nextCursor from a previous page'),
+    }),
+    execute: async ({ newRelicApiKey, query, domain, type, infrastructureIntegrationType, cursor }) => {
+        if (query && (domain || type || infrastructureIntegrationType)) {
+            return { error: 'Provide either query or queryBuilder fields (domain/type), not both' };
+        }
+        const searchArgs = [];
+        if (query)
+            searchArgs.push(`query: ${JSON.stringify(query)}`);
+        else {
+            const qb = [];
+            if (domain)
+                qb.push(`domain: ${JSON.stringify(domain)}`);
+            if (type)
+                qb.push(`type: ${JSON.stringify(type)}`);
+            if (infrastructureIntegrationType)
+                qb.push(`infrastructureIntegrationType: ${JSON.stringify(infrastructureIntegrationType)}`);
+            if (qb.length)
+                searchArgs.push(`queryBuilder: { ${qb.join(', ')} }`);
+        }
+        return nerdgraph(newRelicApiKey, `query($cursor: String) { actor { entitySearch(${searchArgs.join(', ')}) { query results(cursor: $cursor) { nextCursor entities { guid name entityType domainType accountId tags { key values } } } } } }`, { cursor: cursor ?? null }, 'search entities');
+    },
+});
+export const fetchRulesCollection = tool({
+    description: 'Fetches rules/elements from a Scorecard collection by collection ID. Use cursor pagination via nextCursor.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        collectionId: z.string().describe('Scorecard collection ID'),
+        cursor: z.string().optional().describe('nextCursor from a previous page'),
+    }),
+    execute: async ({ newRelicApiKey, collectionId, cursor }) => nerdgraph(newRelicApiKey, `query($collectionId: [ID!]!, $cursor: String) { actor { entityManagement { collectionElements(collectionIds: $collectionId, cursor: $cursor) { items { id name type } nextCursor } } } }`, { collectionId: [collectionId], cursor: cursor ?? null }, 'fetch rules collection'),
+});
+export const fetchYourOrgId = tool({
+    description: 'Returns the organization ID and name for the API key owner. Takes no inputs — run first when the org ID is unknown.',
+    inputSchema: z.object({ newRelicApiKey: newRelicApiKeyField }),
+    execute: async ({ newRelicApiKey }) => nerdgraph(newRelicApiKey, 'query { actor { organization { id name } } }', undefined, 'fetch organization ID'),
+});
+export const queryCloudProviders = tool({
+    description: 'Lists cloud integration providers (AWS, GCP, Azure) configured for an account. Use before linking accounts or configuring integrations.',
+    inputSchema: z.object({
+        newRelicApiKey: newRelicApiKeyField,
+        accountId: accountIdField('Account ID to query cloud providers for'),
+    }),
+    execute: async ({ newRelicApiKey, accountId }) => nerdgraph(newRelicApiKey, `query($accountId: Int!) { actor { account(id: $accountId) { cloud { providers { id name slug } } } } }`, { accountId }, 'query cloud providers'),
+});
+//# sourceMappingURL=nrql.js.map

package/dist/toolkits/new-relic/tools/synthetics.d.ts

@@ -0,0 +1,176 @@
+export declare const createMonitor: import("ai").Tool<{
+    type: "SIMPLE" | "BROWSER" | "SCRIPT_API" | "SCRIPT_BROWSER";
+    status: "ENABLED" | "DISABLED";
+    name: string;
+    frequency: number;
+    locations: string[];
+    newRelicApiKey?: string | undefined;
+    uri?: string | undefined;
+}, any>;
+export declare const getSynthMonitor: import("ai").Tool<{
+    monitorId: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const listMonitors: import("ai").Tool<{
+    limit?: number | undefined;
+    newRelicApiKey?: string | undefined;
+    offset?: number | undefined;
+}, any>;
+export declare const patchMonitor: import("ai").Tool<{
+    monitorId: string;
+    type?: "SIMPLE" | "BROWSER" | "SCRIPT_API" | "SCRIPT_BROWSER" | undefined;
+    status?: "ENABLED" | "DISABLED" | undefined;
+    name?: string | undefined;
+    newRelicApiKey?: string | undefined;
+    frequency?: number | undefined;
+    locations?: string[] | undefined;
+    uri?: string | undefined;
+    slaThreshold?: number | undefined;
+}, any>;
+export declare const updateSynthMonitor: import("ai").Tool<{
+    type: "SIMPLE" | "BROWSER" | "SCRIPT_API" | "SCRIPT_BROWSER";
+    status: "ENABLED" | "DISABLED";
+    name: string;
+    monitorId: string;
+    frequency: number;
+    locations: string[];
+    uri: string;
+    newRelicApiKey?: string | undefined;
+    slaThreshold?: number | undefined;
+}, any>;
+export declare const deleteMonitor: import("ai").Tool<{
+    monitorId: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const updateMonitorScript: import("ai").Tool<{
+    monitorId: string;
+    scriptText: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const listLocations: import("ai").Tool<{
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const createSyntheticsSimpleMonitor: import("ai").Tool<{
+    status: "ENABLED" | "DISABLED";
+    name: string;
+    period: "EVERY_MINUTE" | "EVERY_5_MINUTES" | "EVERY_10_MINUTES" | "EVERY_15_MINUTES" | "EVERY_30_MINUTES" | "EVERY_HOUR" | "EVERY_6_HOURS" | "EVERY_12_HOURS" | "EVERY_DAY";
+    accountId: number;
+    locations: {
+        public: string[];
+    };
+    uri: string;
+    newRelicApiKey?: string | undefined;
+    advancedOptions?: {
+        customHeaders?: {
+            value: string;
+            name: string;
+        }[] | undefined;
+        useTlsValidation?: boolean | undefined;
+        responseValidationText?: string | undefined;
+    } | undefined;
+}, any>;
+export declare const updateSyntheticsSimpleMonitor: import("ai").Tool<{
+    guid: string;
+    monitor: {
+        status?: "ENABLED" | "DISABLED" | undefined;
+        name?: string | undefined;
+        period?: "EVERY_MINUTE" | "EVERY_5_MINUTES" | "EVERY_10_MINUTES" | "EVERY_15_MINUTES" | "EVERY_30_MINUTES" | "EVERY_HOUR" | "EVERY_6_HOURS" | "EVERY_12_HOURS" | "EVERY_DAY" | undefined;
+        locations?: string[] | undefined;
+        uri?: string | undefined;
+        advancedOptions?: {
+            customHeaders?: {
+                value: string;
+                name: string;
+            }[] | undefined;
+            useTlsValidation?: boolean | undefined;
+            responseValidationText?: string | undefined;
+            redirectIsFailure?: boolean | undefined;
+            shouldBypassHeadRequest?: boolean | undefined;
+        } | undefined;
+        apdexTarget?: number | undefined;
+    };
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const createScriptedMonitor: import("ai").Tool<{
+    name: string;
+    runtime: {
+        runtimeType: string;
+        runtimeTypeVersion: string;
+        scriptLanguage?: string | undefined;
+    };
+    period: "EVERY_MINUTE" | "EVERY_5_MINUTES" | "EVERY_10_MINUTES" | "EVERY_15_MINUTES" | "EVERY_30_MINUTES" | "EVERY_HOUR" | "EVERY_6_HOURS" | "EVERY_12_HOURS" | "EVERY_DAY";
+    accountId: number;
+    locations: {
+        private?: string[] | undefined;
+        public?: string[] | undefined;
+    };
+    monitorType: "SCRIPT_API" | "SCRIPT_BROWSER";
+    script: string;
+    status?: "ENABLED" | "DISABLED" | "MUTED" | undefined;
+    newRelicApiKey?: string | undefined;
+    advancedOptions?: Record<string, any> | undefined;
+}, any>;
+export declare const updateScriptedMonitor: import("ai").Tool<{
+    guid: string;
+    monitor: {
+        status?: "ENABLED" | "DISABLED" | "MUTED" | undefined;
+        name?: string | undefined;
+        period?: "EVERY_MINUTE" | "EVERY_5_MINUTES" | "EVERY_10_MINUTES" | "EVERY_15_MINUTES" | "EVERY_30_MINUTES" | "EVERY_HOUR" | "EVERY_6_HOURS" | "EVERY_12_HOURS" | "EVERY_DAY" | undefined;
+        locations?: {
+            private?: string[] | undefined;
+            public?: string[] | undefined;
+        } | undefined;
+        apdexTarget?: number | undefined;
+        script?: string | undefined;
+    };
+    monitorType: "SCRIPT_API" | "SCRIPT_BROWSER";
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const createBrokenLinksMonitor: import("ai").Tool<{
+    status: "ENABLED" | "DISABLED";
+    name: string;
+    runtime: {
+        runtimeType: string;
+        runtimeTypeVersion: string;
+    };
+    period: "EVERY_MINUTE" | "EVERY_5_MINUTES" | "EVERY_10_MINUTES" | "EVERY_15_MINUTES" | "EVERY_30_MINUTES" | "EVERY_HOUR" | "EVERY_6_HOURS" | "EVERY_12_HOURS" | "EVERY_DAY";
+    accountId: number;
+    locations: {
+        private?: string[] | undefined;
+        public?: string[] | undefined;
+    };
+    uri: string;
+    tags?: {
+        values: string[];
+        key: string;
+    }[] | undefined;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const createSyntheticsPrivateLocation: import("ai").Tool<{
+    name: string;
+    accountId: number;
+    description?: string | undefined;
+    newRelicApiKey?: string | undefined;
+    verifiedScriptExecution?: boolean | undefined;
+}, any>;
+export declare const deleteSyntheticsPrivateLocation: import("ai").Tool<{
+    guid: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const deleteSyntheticsMonitorGraphql: import("ai").Tool<{
+    guid: string;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const createSyntheticsSecureCredential: import("ai").Tool<{
+    value: string;
+    key: string;
+    accountId: number;
+    description?: string | undefined;
+    newRelicApiKey?: string | undefined;
+}, any>;
+export declare const deleteSyntheticsSecureCredential: import("ai").Tool<{
+    key: string;
+    accountId: number;
+    newRelicApiKey?: string | undefined;
+}, any>;
+//# sourceMappingURL=synthetics.d.ts.map