@keystrokehq/new_relic 0.1.0 → 0.1.3

package/dist/actions/create-infra-condition.d.cts

@@ -1,9 +1,75 @@
 import { z } from "zod";
 
 //#region src/actions/create-infra-condition.d.ts
-declare const NewRelicCreateInfraConditionInput: z.ZodTypeAny;
-declare const NewRelicCreateInfraConditionOutput: z.ZodTypeAny;
-declare const newRelicCreateInfraCondition: import("@keystrokehq/action").WorkflowActionDefinition<unknown, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
+declare const NewRelicCreateInfraConditionInput: z.ZodObject<{
+  name: z.ZodString;
+  type: z.ZodEnum<{
+    infra_metric: "infra_metric";
+    infra_process_running: "infra_process_running";
+    infra_host_not_reporting: "infra_host_not_reporting";
+  }>;
+  enabled: z.ZodBoolean;
+  policy_id: z.ZodNumber;
+  comparison: z.ZodOptional<z.ZodEnum<{
+    above: "above";
+    below: "below";
+    equal: "equal";
+  }>>;
+  event_type: z.ZodOptional<z.ZodString>;
+  select_value: z.ZodOptional<z.ZodString>;
+  where_clause: z.ZodOptional<z.ZodString>;
+  warning_threshold: z.ZodOptional<z.ZodObject<{
+    value: z.ZodNumber;
+    time_function: z.ZodEnum<{
+      any: "any";
+      all: "all";
+    }>;
+    duration_minutes: z.ZodNumber;
+  }, z.core.$strip>>;
+  critical_threshold: z.ZodOptional<z.ZodObject<{
+    value: z.ZodNumber;
+    time_function: z.ZodEnum<{
+      any: "any";
+      all: "all";
+    }>;
+    duration_minutes: z.ZodNumber;
+  }, z.core.$strip>>;
+  process_where_clause: z.ZodOptional<z.ZodString>;
+  violation_close_timer: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const NewRelicCreateInfraConditionOutput: z.ZodObject<{
+  data: z.ZodNullable<z.ZodObject<{
+    id: z.ZodNullable<z.ZodNumber>;
+    name: z.ZodNullable<z.ZodString>;
+    type: z.ZodNullable<z.ZodString>;
+    enabled: z.ZodNullable<z.ZodBoolean>;
+    policy_id: z.ZodNullable<z.ZodNumber>;
+    created_at_epoch_millis: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    updated_at_epoch_millis: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  }, z.core.$loose>>;
+}, z.core.$loose>;
+declare const newRelicCreateInfraCondition: import("@keystrokehq/action").WorkflowActionDefinition<{
+  name: string;
+  type: "infra_metric" | "infra_process_running" | "infra_host_not_reporting";
+  enabled: boolean;
+  policy_id: number;
+  comparison?: "above" | "below" | "equal" | undefined;
+  event_type?: string | undefined;
+  select_value?: string | undefined;
+  where_clause?: string | undefined;
+  warning_threshold?: {
+    value: number;
+    time_function: "any" | "all";
+    duration_minutes: number;
+  } | undefined;
+  critical_threshold?: {
+    value: number;
+    time_function: "any" | "all";
+    duration_minutes: number;
+  } | undefined;
+  process_where_clause?: string | undefined;
+  violation_close_timer?: number | undefined;
+}, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
 //#endregion
 export { newRelicCreateInfraCondition };
 //# sourceMappingURL=create-infra-condition.d.cts.map

package/dist/actions/create-infra-condition.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"create-infra-condition.d.cts","names":[],"sources":["../../src/actions/create-infra-condition.ts"],"mappings":";;;cAIa,iCAAA,EAAmC,CAAA,CAAE,UAqB+B;AAAA,cAUpE,kCAAA,EAAoC,CAAA,CAAE,UAEqB;AAAA,cAE3D,4BAAA,gCAA4B,wBAAA,iDAAA,mBAAA,yCAAA,UAAA,4CAAA,UAAA"}
+{"version":3,"file":"create-infra-condition.d.cts","names":[],"sources":["../../src/actions/create-infra-condition.ts"],"mappings":";;;cAIa,iCAAA,EAAiC,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BjC,kCAAA,EAAkC,CAAA,CAAA,SAAA;;;;;;;;;;;cAIlC,4BAAA,gCAA4B,wBAAA"}

package/dist/actions/create-infra-condition.d.mts

@@ -1,9 +1,75 @@
 import { z } from "zod";
 
 //#region src/actions/create-infra-condition.d.ts
-declare const NewRelicCreateInfraConditionInput: z.ZodTypeAny;
-declare const NewRelicCreateInfraConditionOutput: z.ZodTypeAny;
-declare const newRelicCreateInfraCondition: import("@keystrokehq/action").WorkflowActionDefinition<unknown, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
+declare const NewRelicCreateInfraConditionInput: z.ZodObject<{
+  name: z.ZodString;
+  type: z.ZodEnum<{
+    infra_metric: "infra_metric";
+    infra_process_running: "infra_process_running";
+    infra_host_not_reporting: "infra_host_not_reporting";
+  }>;
+  enabled: z.ZodBoolean;
+  policy_id: z.ZodNumber;
+  comparison: z.ZodOptional<z.ZodEnum<{
+    above: "above";
+    below: "below";
+    equal: "equal";
+  }>>;
+  event_type: z.ZodOptional<z.ZodString>;
+  select_value: z.ZodOptional<z.ZodString>;
+  where_clause: z.ZodOptional<z.ZodString>;
+  warning_threshold: z.ZodOptional<z.ZodObject<{
+    value: z.ZodNumber;
+    time_function: z.ZodEnum<{
+      any: "any";
+      all: "all";
+    }>;
+    duration_minutes: z.ZodNumber;
+  }, z.core.$strip>>;
+  critical_threshold: z.ZodOptional<z.ZodObject<{
+    value: z.ZodNumber;
+    time_function: z.ZodEnum<{
+      any: "any";
+      all: "all";
+    }>;
+    duration_minutes: z.ZodNumber;
+  }, z.core.$strip>>;
+  process_where_clause: z.ZodOptional<z.ZodString>;
+  violation_close_timer: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const NewRelicCreateInfraConditionOutput: z.ZodObject<{
+  data: z.ZodNullable<z.ZodObject<{
+    id: z.ZodNullable<z.ZodNumber>;
+    name: z.ZodNullable<z.ZodString>;
+    type: z.ZodNullable<z.ZodString>;
+    enabled: z.ZodNullable<z.ZodBoolean>;
+    policy_id: z.ZodNullable<z.ZodNumber>;
+    created_at_epoch_millis: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    updated_at_epoch_millis: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  }, z.core.$loose>>;
+}, z.core.$loose>;
+declare const newRelicCreateInfraCondition: import("@keystrokehq/action").WorkflowActionDefinition<{
+  name: string;
+  type: "infra_metric" | "infra_process_running" | "infra_host_not_reporting";
+  enabled: boolean;
+  policy_id: number;
+  comparison?: "above" | "below" | "equal" | undefined;
+  event_type?: string | undefined;
+  select_value?: string | undefined;
+  where_clause?: string | undefined;
+  warning_threshold?: {
+    value: number;
+    time_function: "any" | "all";
+    duration_minutes: number;
+  } | undefined;
+  critical_threshold?: {
+    value: number;
+    time_function: "any" | "all";
+    duration_minutes: number;
+  } | undefined;
+  process_where_clause?: string | undefined;
+  violation_close_timer?: number | undefined;
+}, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
 //#endregion
 export { newRelicCreateInfraCondition };
 //# sourceMappingURL=create-infra-condition.d.mts.map

package/dist/actions/create-infra-condition.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"create-infra-condition.d.mts","names":[],"sources":["../../src/actions/create-infra-condition.ts"],"mappings":";;;cAIa,iCAAA,EAAmC,CAAA,CAAE,UAqB+B;AAAA,cAUpE,kCAAA,EAAoC,CAAA,CAAE,UAEqB;AAAA,cAE3D,4BAAA,gCAA4B,wBAAA,iDAAA,mBAAA,yCAAA,UAAA,4CAAA,UAAA"}
+{"version":3,"file":"create-infra-condition.d.mts","names":[],"sources":["../../src/actions/create-infra-condition.ts"],"mappings":";;;cAIa,iCAAA,EAAiC,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BjC,kCAAA,EAAkC,CAAA,CAAA,SAAA;;;;;;;;;;;cAIlC,4BAAA,gCAA4B,wBAAA"}

package/dist/actions/create-infra-condition.mjs

@@ -32,20 +32,20 @@ const NewRelicCreateInfraConditionInput = z.object({
 	violation_close_timer: z.number().int().describe("Duration in hours after which a violation automatically closes if the condition is no longer met. Must be between 1 and 720 hours.").optional()
 }).describe("Request parameters for creating an infrastructure alert condition.");
 const NewRelicCreateInfraCondition_InfraConditionDataSchema = z.object({
-	id: z.number().int().describe("Unique identifier for the created infrastructure alert condition."),
-	name: z.string().describe("Name of the alert condition."),
-	type: z.string().describe("Type of infrastructure condition."),
-	enabled: z.boolean().describe("Whether the condition is enabled."),
-	policy_id: z.number().int().describe("ID of the alert policy this condition belongs to."),
+	id: z.number().int().describe("Unique identifier for the created infrastructure alert condition.").nullable(),
+	name: z.string().describe("Name of the alert condition.").nullable(),
+	type: z.string().describe("Type of infrastructure condition.").nullable(),
+	enabled: z.boolean().describe("Whether the condition is enabled.").nullable(),
+	policy_id: z.number().int().describe("ID of the alert policy this condition belongs to.").nullable(),
 	created_at_epoch_millis: z.number().int().describe("Timestamp when the condition was created (milliseconds since epoch).").nullable().optional(),
 	updated_at_epoch_millis: z.number().int().describe("Timestamp when the condition was last updated (milliseconds since epoch).").nullable().optional()
-}).describe("Infrastructure alert condition data returned by the API.");
+}).passthrough().describe("Infrastructure alert condition data returned by the API.");
 const newRelicCreateInfraCondition = action("NEW_RELIC_CREATE_INFRA_CONDITION", {
 	slug: "new_relic-create-infra-condition",
 	name: "Create Infrastructure Alert Condition",
 	description: "Tool to create an infrastructure alert condition in New Relic. Use when you need to monitor infrastructure metrics (CPU, memory, disk), detect when processes stop running, or alert when hosts stop reporting. Supports critical and warning thresholds.",
 	input: NewRelicCreateInfraConditionInput,
-	output: z.object({ data: NewRelicCreateInfraCondition_InfraConditionDataSchema.nullable() }).describe("Response from creating an infrastructure alert condition.")
+	output: z.object({ data: NewRelicCreateInfraCondition_InfraConditionDataSchema.nullable() }).passthrough().describe("Response from creating an infrastructure alert condition.")
 });
 //#endregion
 export { newRelicCreateInfraCondition };

package/dist/actions/create-infra-condition.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-infra-condition.mjs","names":[],"sources":["../../src/actions/create-infra-condition.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateInfraConditionInput: z.ZodTypeAny = z.object({\n  name: z.string().describe(\"Name of the infrastructure alert condition. Must be unique within the policy.\"),\n  type: z.enum([\"infra_metric\", \"infra_process_running\", \"infra_host_not_reporting\"]).describe(\"Type of infrastructure condition to create.\"),\n  enabled: z.boolean().describe(\"Whether the alert condition is enabled and actively monitoring.\"),\n  policy_id: z.number().int().describe(\"The ID of the alert policy to attach this condition to.\"),\n  comparison: z.enum([\"above\", \"below\", \"equal\"]).describe(\"Comparison operator for metric conditions.\").optional(),\n  event_type: z.string().describe(\"Event type to monitor for infra_metric conditions (e.g., SystemSample, StorageSample, NetworkSample, ProcessSample). Required for infra_metric type.\").optional(),\n  select_value: z.string().describe(\"Metric to monitor for infra_metric conditions (e.g., cpuPercent, diskUsedPercent, memoryUsedPercent). Required for infra_metric type.\").optional(),\n  where_clause: z.string().describe(\"Optional WHERE clause to filter which infrastructure entities the condition applies to (e.g., \\\"hostname LIKE 'prod-%'\\\").\").optional(),\n  warning_threshold: z.object({\n  value: z.number().describe(\"The threshold value that triggers the alert.\"),\n  time_function: z.enum([\"all\", \"any\"]).describe(\"How to evaluate the threshold over the duration. 'all' means every data point must violate, 'any' means at least one must violate.\"),\n  duration_minutes: z.number().int().describe(\"Duration in minutes that the threshold must be violated before triggering an alert.\"),\n}).describe(\"Threshold configuration for alert conditions.\").optional(),\n  critical_threshold: z.object({\n  value: z.number().describe(\"The threshold value that triggers the alert.\"),\n  time_function: z.enum([\"all\", \"any\"]).describe(\"How to evaluate the threshold over the duration. 'all' means every data point must violate, 'any' means at least one must violate.\"),\n  duration_minutes: z.number().int().describe(\"Duration in minutes that the threshold must be violated before triggering an alert.\"),\n}).describe(\"Threshold configuration for alert conditions.\").optional(),\n  process_where_clause: z.string().describe(\"Optional WHERE clause for infra_process_running conditions to identify the process (e.g., \\\"commandName = 'java'\\\").\").optional(),\n  violation_close_timer: z.number().int().describe(\"Duration in hours after which a violation automatically closes if the condition is no longer met. Must be between 1 and 720 hours.\").optional(),\n}).describe(\"Request parameters for creating an infrastructure alert condition.\");\nconst NewRelicCreateInfraCondition_InfraConditionDataSchema: z.ZodTypeAny = z.object({\n  id: z.number().int().describe(\"Unique identifier for the created infrastructure alert condition.\"),\n  name: z.string().describe(\"Name of the alert condition.\"),\n  type: z.string().describe(\"Type of infrastructure condition.\"),\n  enabled: z.boolean().describe(\"Whether the condition is enabled.\"),\n  policy_id: z.number().int().describe(\"ID of the alert policy this condition belongs to.\"),\n  created_at_epoch_millis: z.number().int().describe(\"Timestamp when the condition was created (milliseconds since epoch).\").nullable().optional(),\n  updated_at_epoch_millis: z.number().int().describe(\"Timestamp when the condition was last updated (milliseconds since epoch).\").nullable().optional(),\n}).describe(\"Infrastructure alert condition data returned by the API.\");\nexport const NewRelicCreateInfraConditionOutput: z.ZodTypeAny = z.object({\n  data: NewRelicCreateInfraCondition_InfraConditionDataSchema.nullable(),\n}).describe(\"Response from creating an infrastructure alert condition.\");\n\nexport const newRelicCreateInfraCondition = action(\"NEW_RELIC_CREATE_INFRA_CONDITION\", {\n  slug: \"new_relic-create-infra-condition\",\n  name: \"Create Infrastructure Alert Condition\",\n  description: \"Tool to create an infrastructure alert condition in New Relic. Use when you need to monitor infrastructure metrics (CPU, memory, disk), detect when processes stop running, or alert when hosts stop reporting. Supports critical and warning thresholds.\",\n  input: NewRelicCreateInfraConditionInput,\n  output: NewRelicCreateInfraConditionOutput,\n});\n"],"mappings":";;;AAIA,MAAa,oCAAkD,EAAE,OAAO;CACtE,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,+EAA+E;CACzG,MAAM,EAAE,KAAK;EAAC;EAAgB;EAAyB;CAA0B,CAAC,CAAC,CAAC,SAAS,6CAA6C;CAC1I,SAAS,EAAE,QAAQ,CAAC,CAAC,SAAS,iEAAiE;CAC/F,WAAW,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,yDAAyD;CAC9F,YAAY,EAAE,KAAK;EAAC;EAAS;EAAS;CAAO,CAAC,CAAC,CAAC,SAAS,4CAA4C,CAAC,CAAC,SAAS;CAChH,YAAY,EAAE,OAAO,CAAC,CAAC,SAAS,sJAAsJ,CAAC,CAAC,SAAS;CACjM,cAAc,EAAE,OAAO,CAAC,CAAC,SAAS,uIAAuI,CAAC,CAAC,SAAS;CACpL,cAAc,EAAE,OAAO,CAAC,CAAC,SAAS,4HAA4H,CAAC,CAAC,SAAS;CACzK,mBAAmB,EAAE,OAAO;EAC5B,OAAO,EAAE,OAAO,CAAC,CAAC,SAAS,8CAA8C;EACzE,eAAe,EAAE,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,SAAS,oIAAoI;EACnL,kBAAkB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,qFAAqF;CACnI,CAAC,CAAC,CAAC,SAAS,+CAA+C,CAAC,CAAC,SAAS;CACpE,oBAAoB,EAAE,OAAO;EAC7B,OAAO,EAAE,OAAO,CAAC,CAAC,SAAS,8CAA8C;EACzE,eAAe,EAAE,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,SAAS,oIAAoI;EACnL,kBAAkB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,qFAAqF;CACnI,CAAC,CAAC,CAAC,SAAS,+CAA+C,CAAC,CAAC,SAAS;CACpE,sBAAsB,EAAE,OAAO,CAAC,CAAC,SAAS,sHAAsH,CAAC,CAAC,SAAS;CAC3K,uBAAuB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,oIAAoI,CAAC,CAAC,SAAS;AAClM,CAAC,CAAC,CAAC,SAAS,oEAAoE;AAChF,MAAM,wDAAsE,EAAE,OAAO;CACnF,IAAI,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,mEAAmE;CACjG,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,8BAA8B;CACxD,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,mCAAmC;CAC7D,SAAS,EAAE,QAAQ,CAAC,CAAC,SAAS,mCAAmC;CACjE,WAAW,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,mDAAmD;CACxF,yBAAyB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,sEAAsE,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS;CAC/I,yBAAyB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,2EAA2E,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS;AACtJ,CAAC,CAAC,CAAC,SAAS,0DAA0D;AAKtE,MAAa,+BAA+B,OAAO,oCAAoC;CACrF,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAAO;CACP,QAT8D,EAAE,OAAO,EACvE,MAAM,sDAAsD,SAAS,EACvE,CAAC,CAAC,CAAC,SAAS,2DAOF;AACV,CAAC"}
+{"version":3,"file":"create-infra-condition.mjs","names":[],"sources":["../../src/actions/create-infra-condition.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateInfraConditionInput = z.object({\n  name: z.string().describe(\"Name of the infrastructure alert condition. Must be unique within the policy.\"),\n  type: z.enum([\"infra_metric\", \"infra_process_running\", \"infra_host_not_reporting\"]).describe(\"Type of infrastructure condition to create.\"),\n  enabled: z.boolean().describe(\"Whether the alert condition is enabled and actively monitoring.\"),\n  policy_id: z.number().int().describe(\"The ID of the alert policy to attach this condition to.\"),\n  comparison: z.enum([\"above\", \"below\", \"equal\"]).describe(\"Comparison operator for metric conditions.\").optional(),\n  event_type: z.string().describe(\"Event type to monitor for infra_metric conditions (e.g., SystemSample, StorageSample, NetworkSample, ProcessSample). Required for infra_metric type.\").optional(),\n  select_value: z.string().describe(\"Metric to monitor for infra_metric conditions (e.g., cpuPercent, diskUsedPercent, memoryUsedPercent). Required for infra_metric type.\").optional(),\n  where_clause: z.string().describe(\"Optional WHERE clause to filter which infrastructure entities the condition applies to (e.g., \\\"hostname LIKE 'prod-%'\\\").\").optional(),\n  warning_threshold: z.object({\n  value: z.number().describe(\"The threshold value that triggers the alert.\"),\n  time_function: z.enum([\"all\", \"any\"]).describe(\"How to evaluate the threshold over the duration. 'all' means every data point must violate, 'any' means at least one must violate.\"),\n  duration_minutes: z.number().int().describe(\"Duration in minutes that the threshold must be violated before triggering an alert.\"),\n}).describe(\"Threshold configuration for alert conditions.\").optional(),\n  critical_threshold: z.object({\n  value: z.number().describe(\"The threshold value that triggers the alert.\"),\n  time_function: z.enum([\"all\", \"any\"]).describe(\"How to evaluate the threshold over the duration. 'all' means every data point must violate, 'any' means at least one must violate.\"),\n  duration_minutes: z.number().int().describe(\"Duration in minutes that the threshold must be violated before triggering an alert.\"),\n}).describe(\"Threshold configuration for alert conditions.\").optional(),\n  process_where_clause: z.string().describe(\"Optional WHERE clause for infra_process_running conditions to identify the process (e.g., \\\"commandName = 'java'\\\").\").optional(),\n  violation_close_timer: z.number().int().describe(\"Duration in hours after which a violation automatically closes if the condition is no longer met. Must be between 1 and 720 hours.\").optional(),\n}).describe(\"Request parameters for creating an infrastructure alert condition.\");\nconst NewRelicCreateInfraCondition_InfraConditionDataSchema = z.object({\n  id: z.number().int().describe(\"Unique identifier for the created infrastructure alert condition.\").nullable(),\n  name: z.string().describe(\"Name of the alert condition.\").nullable(),\n  type: z.string().describe(\"Type of infrastructure condition.\").nullable(),\n  enabled: z.boolean().describe(\"Whether the condition is enabled.\").nullable(),\n  policy_id: z.number().int().describe(\"ID of the alert policy this condition belongs to.\").nullable(),\n  created_at_epoch_millis: z.number().int().describe(\"Timestamp when the condition was created (milliseconds since epoch).\").nullable().optional(),\n  updated_at_epoch_millis: z.number().int().describe(\"Timestamp when the condition was last updated (milliseconds since epoch).\").nullable().optional(),\n}).passthrough().describe(\"Infrastructure alert condition data returned by the API.\");\nexport const NewRelicCreateInfraConditionOutput = z.object({\n  data: NewRelicCreateInfraCondition_InfraConditionDataSchema.nullable(),\n}).passthrough().describe(\"Response from creating an infrastructure alert condition.\");\n\nexport const newRelicCreateInfraCondition = action(\"NEW_RELIC_CREATE_INFRA_CONDITION\", {\n  slug: \"new_relic-create-infra-condition\",\n  name: \"Create Infrastructure Alert Condition\",\n  description: \"Tool to create an infrastructure alert condition in New Relic. Use when you need to monitor infrastructure metrics (CPU, memory, disk), detect when processes stop running, or alert when hosts stop reporting. Supports critical and warning thresholds.\",\n  input: NewRelicCreateInfraConditionInput,\n  output: NewRelicCreateInfraConditionOutput,\n});\n"],"mappings":";;;AAIA,MAAa,oCAAoC,EAAE,OAAO;CACxD,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,+EAA+E;CACzG,MAAM,EAAE,KAAK;EAAC;EAAgB;EAAyB;CAA0B,CAAC,CAAC,CAAC,SAAS,6CAA6C;CAC1I,SAAS,EAAE,QAAQ,CAAC,CAAC,SAAS,iEAAiE;CAC/F,WAAW,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,yDAAyD;CAC9F,YAAY,EAAE,KAAK;EAAC;EAAS;EAAS;CAAO,CAAC,CAAC,CAAC,SAAS,4CAA4C,CAAC,CAAC,SAAS;CAChH,YAAY,EAAE,OAAO,CAAC,CAAC,SAAS,sJAAsJ,CAAC,CAAC,SAAS;CACjM,cAAc,EAAE,OAAO,CAAC,CAAC,SAAS,uIAAuI,CAAC,CAAC,SAAS;CACpL,cAAc,EAAE,OAAO,CAAC,CAAC,SAAS,4HAA4H,CAAC,CAAC,SAAS;CACzK,mBAAmB,EAAE,OAAO;EAC5B,OAAO,EAAE,OAAO,CAAC,CAAC,SAAS,8CAA8C;EACzE,eAAe,EAAE,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,SAAS,oIAAoI;EACnL,kBAAkB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,qFAAqF;CACnI,CAAC,CAAC,CAAC,SAAS,+CAA+C,CAAC,CAAC,SAAS;CACpE,oBAAoB,EAAE,OAAO;EAC7B,OAAO,EAAE,OAAO,CAAC,CAAC,SAAS,8CAA8C;EACzE,eAAe,EAAE,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC,CAAC,SAAS,oIAAoI;EACnL,kBAAkB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,qFAAqF;CACnI,CAAC,CAAC,CAAC,SAAS,+CAA+C,CAAC,CAAC,SAAS;CACpE,sBAAsB,EAAE,OAAO,CAAC,CAAC,SAAS,sHAAsH,CAAC,CAAC,SAAS;CAC3K,uBAAuB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,oIAAoI,CAAC,CAAC,SAAS;AAClM,CAAC,CAAC,CAAC,SAAS,oEAAoE;AAChF,MAAM,wDAAwD,EAAE,OAAO;CACrE,IAAI,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,mEAAmE,CAAC,CAAC,SAAS;CAC5G,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,8BAA8B,CAAC,CAAC,SAAS;CACnE,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,mCAAmC,CAAC,CAAC,SAAS;CACxE,SAAS,EAAE,QAAQ,CAAC,CAAC,SAAS,mCAAmC,CAAC,CAAC,SAAS;CAC5E,WAAW,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,mDAAmD,CAAC,CAAC,SAAS;CACnG,yBAAyB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,sEAAsE,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS;CAC/I,yBAAyB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,2EAA2E,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS;AACtJ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,0DAA0D;AAKpF,MAAa,+BAA+B,OAAO,oCAAoC;CACrF,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAAO;CACP,QATgD,EAAE,OAAO,EACzD,MAAM,sDAAsD,SAAS,EACvE,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,2DAOhB;AACV,CAAC"}

package/dist/actions/create-location-failure-condition.cjs

@@ -6,7 +6,7 @@ const NewRelicCreateLocationFailureConditionInput = zod.z.object({
 	terms: zod.z.array(zod.z.object({
 		priority: zod.z.enum(["critical", "warning"]).describe("Alert priority level. Critical alerts require immediate attention, warning alerts are informational."),
 		threshold: zod.z.number().int().describe("Number of locations that must fail simultaneously to trigger the alert.")
-	}).describe("Threshold configuration for location failure condition.")).describe("Array of threshold objects that define when alerts are triggered based on number of failing locations."),
+	}).passthrough().describe("Threshold configuration for location failure condition.")).describe("Array of threshold objects that define when alerts are triggered based on number of failing locations."),
 	enabled: zod.z.boolean().default(true).describe("Whether the alert condition is enabled and actively monitoring.").optional(),
 	entities: zod.z.array(zod.z.string()).describe("Array of synthetic monitor IDs (UUIDs) that this condition will monitor. Each ID represents a synthetic monitor to watch for location failures."),
 	policy_id: zod.z.number().int().describe("The ID of the alert policy to attach this location failure condition to. The policy must exist in your New Relic account."),
@@ -14,19 +14,19 @@ const NewRelicCreateLocationFailureConditionInput = zod.z.object({
 	violation_time_limit_seconds: zod.z.number().int().default(86400).describe("How long in seconds an incident remains open before automatically closing. Default is 86400 seconds (24 hours).").optional()
 }).describe("Request parameters for creating a location failure alert condition.");
 const NewRelicCreateLocationFailureCondition_TermSchema = zod.z.object({
-	priority: zod.z.string().describe("Alert priority level."),
-	threshold: zod.z.number().int().describe("Number of locations that must fail to trigger the alert.")
-}).describe("Term details in the response.");
+	priority: zod.z.string().describe("Alert priority level.").nullable(),
+	threshold: zod.z.number().int().describe("Number of locations that must fail to trigger the alert.").nullable()
+}).passthrough().describe("Term details in the response.");
 const NewRelicCreateLocationFailureCondition_LocationFailureConditionSchema = zod.z.object({
-	id: zod.z.number().int().describe("Unique identifier for the created location failure condition."),
-	name: zod.z.string().describe("Name of the location failure condition."),
+	id: zod.z.number().int().describe("Unique identifier for the created location failure condition.").nullable(),
+	name: zod.z.string().describe("Name of the location failure condition.").nullable(),
 	terms: zod.z.array(NewRelicCreateLocationFailureCondition_TermSchema).describe("List of threshold terms for the condition."),
-	enabled: zod.z.boolean().describe("Whether the condition is enabled."),
+	enabled: zod.z.boolean().describe("Whether the condition is enabled.").nullable(),
 	entities: zod.z.array(zod.z.string()).describe("Array of synthetic monitor IDs being monitored."),
 	runbook_url: zod.z.string().describe("Optional URL to a runbook for this condition.").nullable().optional(),
-	violation_time_limit_seconds: zod.z.number().int().describe("Maximum duration in seconds an incident can remain open.")
-}).describe("Details of the created location failure condition.");
-const NewRelicCreateLocationFailureConditionOutput = zod.z.object({ location_failure_condition: NewRelicCreateLocationFailureCondition_LocationFailureConditionSchema.nullable() }).describe("Response from creating a location failure alert condition.");
+	violation_time_limit_seconds: zod.z.number().int().describe("Maximum duration in seconds an incident can remain open.").nullable()
+}).passthrough().describe("Details of the created location failure condition.");
+const NewRelicCreateLocationFailureConditionOutput = zod.z.object({ location_failure_condition: NewRelicCreateLocationFailureCondition_LocationFailureConditionSchema.nullable() }).passthrough().describe("Response from creating a location failure alert condition.");
 const newRelicCreateLocationFailureCondition = require_action.action("NEW_RELIC_CREATE_LOCATION_FAILURE_CONDITION", {
 	slug: "new_relic-create-location-failure-condition",
 	name: "Create Location Failure Alert Condition",

package/dist/actions/create-location-failure-condition.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-location-failure-condition.cjs","names":["z","action"],"sources":["../../src/actions/create-location-failure-condition.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateLocationFailureConditionInput: z.ZodTypeAny = z.object({\n  name: z.string().describe(\"The name of the multi-location failure condition. Must be unique within the policy.\"),\n  terms: z.array(z.object({\n  priority: z.enum([\"critical\", \"warning\"]).describe(\"Alert priority level. Critical alerts require immediate attention, warning alerts are informational.\"),\n  threshold: z.number().int().describe(\"Number of locations that must fail simultaneously to trigger the alert.\"),\n}).describe(\"Threshold configuration for location failure condition.\")).describe(\"Array of threshold objects that define when alerts are triggered based on number of failing locations.\"),\n  enabled: z.boolean().default(true).describe(\"Whether the alert condition is enabled and actively monitoring.\").optional(),\n  entities: z.array(z.string()).describe(\"Array of synthetic monitor IDs (UUIDs) that this condition will monitor. Each ID represents a synthetic monitor to watch for location failures.\"),\n  policy_id: z.number().int().describe(\"The ID of the alert policy to attach this location failure condition to. The policy must exist in your New Relic account.\"),\n  runbook_url: z.string().describe(\"Optional URL to a runbook providing instructions for responding to this alert condition.\").optional(),\n  violation_time_limit_seconds: z.number().int().default(86400).describe(\"How long in seconds an incident remains open before automatically closing. Default is 86400 seconds (24 hours).\").optional(),\n}).describe(\"Request parameters for creating a location failure alert condition.\");\nconst NewRelicCreateLocationFailureCondition_TermSchema: z.ZodTypeAny = z.object({\n  priority: z.string().describe(\"Alert priority level.\"),\n  threshold: z.number().int().describe(\"Number of locations that must fail to trigger the alert.\"),\n}).describe(\"Term details in the response.\");\nconst NewRelicCreateLocationFailureCondition_LocationFailureConditionSchema: z.ZodTypeAny = z.object({\n  id: z.number().int().describe(\"Unique identifier for the created location failure condition.\"),\n  name: z.string().describe(\"Name of the location failure condition.\"),\n  terms: z.array(NewRelicCreateLocationFailureCondition_TermSchema).describe(\"List of threshold terms for the condition.\"),\n  enabled: z.boolean().describe(\"Whether the condition is enabled.\"),\n  entities: z.array(z.string()).describe(\"Array of synthetic monitor IDs being monitored.\"),\n  runbook_url: z.string().describe(\"Optional URL to a runbook for this condition.\").nullable().optional(),\n  violation_time_limit_seconds: z.number().int().describe(\"Maximum duration in seconds an incident can remain open.\"),\n}).describe(\"Details of the created location failure condition.\");\nexport const NewRelicCreateLocationFailureConditionOutput: z.ZodTypeAny = z.object({\n  location_failure_condition: NewRelicCreateLocationFailureCondition_LocationFailureConditionSchema.nullable(),\n}).describe(\"Response from creating a location failure alert condition.\");\n\nexport const newRelicCreateLocationFailureCondition = action(\"NEW_RELIC_CREATE_LOCATION_FAILURE_CONDITION\", {\n  slug: \"new_relic-create-location-failure-condition\",\n  name: \"Create Location Failure Alert Condition\",\n  description: \"Tool to create a location failure alert condition in New Relic. Use when you need to monitor synthetic monitors and trigger alerts when multiple locations fail simultaneously.\",\n  input: NewRelicCreateLocationFailureConditionInput,\n  output: NewRelicCreateLocationFailureConditionOutput,\n});\n"],"mappings":";;;AAIA,MAAa,8CAA4DA,IAAAA,EAAE,OAAO;CAChF,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,qFAAqF;CAC/G,OAAOA,IAAAA,EAAE,MAAMA,IAAAA,EAAE,OAAO;EACxB,UAAUA,IAAAA,EAAE,KAAK,CAAC,YAAY,SAAS,CAAC,CAAC,CAAC,SAAS,sGAAsG;EACzJ,WAAWA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,yEAAyE;CAChH,CAAC,CAAC,CAAC,SAAS,yDAAyD,CAAC,CAAC,CAAC,SAAS,wGAAwG;CACvL,SAASA,IAAAA,EAAE,QAAQ,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,SAAS,iEAAiE,CAAC,CAAC,SAAS;CACxH,UAAUA,IAAAA,EAAE,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,CAAC,SAAS,iJAAiJ;CACxL,WAAWA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,2HAA2H;CAChK,aAAaA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,0FAA0F,CAAC,CAAC,SAAS;CACtI,8BAA8BA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,SAAS,iHAAiH,CAAC,CAAC,SAAS;AACrM,CAAC,CAAC,CAAC,SAAS,qEAAqE;AACjF,MAAM,oDAAkEA,IAAAA,EAAE,OAAO;CAC/E,UAAUA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,uBAAuB;CACrD,WAAWA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,0DAA0D;AACjG,CAAC,CAAC,CAAC,SAAS,+BAA+B;AAC3C,MAAM,wEAAsFA,IAAAA,EAAE,OAAO;CACnG,IAAIA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,+DAA+D;CAC7F,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,yCAAyC;CACnE,OAAOA,IAAAA,EAAE,MAAM,iDAAiD,CAAC,CAAC,SAAS,4CAA4C;CACvH,SAASA,IAAAA,EAAE,QAAQ,CAAC,CAAC,SAAS,mCAAmC;CACjE,UAAUA,IAAAA,EAAE,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,CAAC,SAAS,iDAAiD;CACxF,aAAaA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,+CAA+C,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS;CACtG,8BAA8BA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,0DAA0D;AACpH,CAAC,CAAC,CAAC,SAAS,oDAAoD;AAChE,MAAa,+CAA6DA,IAAAA,EAAE,OAAO,EACjF,4BAA4B,sEAAsE,SAAS,EAC7G,CAAC,CAAC,CAAC,SAAS,4DAA4D;AAExE,MAAa,yCAAyCC,eAAAA,OAAO,+CAA+C;CAC1G,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAAO;CACP,QAAQ;AACV,CAAC"}
+{"version":3,"file":"create-location-failure-condition.cjs","names":["z","action"],"sources":["../../src/actions/create-location-failure-condition.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateLocationFailureConditionInput = z.object({\n  name: z.string().describe(\"The name of the multi-location failure condition. Must be unique within the policy.\"),\n  terms: z.array(z.object({\n  priority: z.enum([\"critical\", \"warning\"]).describe(\"Alert priority level. Critical alerts require immediate attention, warning alerts are informational.\"),\n  threshold: z.number().int().describe(\"Number of locations that must fail simultaneously to trigger the alert.\"),\n}).passthrough().describe(\"Threshold configuration for location failure condition.\")).describe(\"Array of threshold objects that define when alerts are triggered based on number of failing locations.\"),\n  enabled: z.boolean().default(true).describe(\"Whether the alert condition is enabled and actively monitoring.\").optional(),\n  entities: z.array(z.string()).describe(\"Array of synthetic monitor IDs (UUIDs) that this condition will monitor. Each ID represents a synthetic monitor to watch for location failures.\"),\n  policy_id: z.number().int().describe(\"The ID of the alert policy to attach this location failure condition to. The policy must exist in your New Relic account.\"),\n  runbook_url: z.string().describe(\"Optional URL to a runbook providing instructions for responding to this alert condition.\").optional(),\n  violation_time_limit_seconds: z.number().int().default(86400).describe(\"How long in seconds an incident remains open before automatically closing. Default is 86400 seconds (24 hours).\").optional(),\n}).describe(\"Request parameters for creating a location failure alert condition.\");\nconst NewRelicCreateLocationFailureCondition_TermSchema = z.object({\n  priority: z.string().describe(\"Alert priority level.\").nullable(),\n  threshold: z.number().int().describe(\"Number of locations that must fail to trigger the alert.\").nullable(),\n}).passthrough().describe(\"Term details in the response.\");\nconst NewRelicCreateLocationFailureCondition_LocationFailureConditionSchema = z.object({\n  id: z.number().int().describe(\"Unique identifier for the created location failure condition.\").nullable(),\n  name: z.string().describe(\"Name of the location failure condition.\").nullable(),\n  terms: z.array(NewRelicCreateLocationFailureCondition_TermSchema).describe(\"List of threshold terms for the condition.\"),\n  enabled: z.boolean().describe(\"Whether the condition is enabled.\").nullable(),\n  entities: z.array(z.string()).describe(\"Array of synthetic monitor IDs being monitored.\"),\n  runbook_url: z.string().describe(\"Optional URL to a runbook for this condition.\").nullable().optional(),\n  violation_time_limit_seconds: z.number().int().describe(\"Maximum duration in seconds an incident can remain open.\").nullable(),\n}).passthrough().describe(\"Details of the created location failure condition.\");\nexport const NewRelicCreateLocationFailureConditionOutput = z.object({\n  location_failure_condition: NewRelicCreateLocationFailureCondition_LocationFailureConditionSchema.nullable(),\n}).passthrough().describe(\"Response from creating a location failure alert condition.\");\n\nexport const newRelicCreateLocationFailureCondition = action(\"NEW_RELIC_CREATE_LOCATION_FAILURE_CONDITION\", {\n  slug: \"new_relic-create-location-failure-condition\",\n  name: \"Create Location Failure Alert Condition\",\n  description: \"Tool to create a location failure alert condition in New Relic. Use when you need to monitor synthetic monitors and trigger alerts when multiple locations fail simultaneously.\",\n  input: NewRelicCreateLocationFailureConditionInput,\n  output: NewRelicCreateLocationFailureConditionOutput,\n});\n"],"mappings":";;;AAIA,MAAa,8CAA8CA,IAAAA,EAAE,OAAO;CAClE,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,qFAAqF;CAC/G,OAAOA,IAAAA,EAAE,MAAMA,IAAAA,EAAE,OAAO;EACxB,UAAUA,IAAAA,EAAE,KAAK,CAAC,YAAY,SAAS,CAAC,CAAC,CAAC,SAAS,sGAAsG;EACzJ,WAAWA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,yEAAyE;CAChH,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,yDAAyD,CAAC,CAAC,CAAC,SAAS,wGAAwG;CACrM,SAASA,IAAAA,EAAE,QAAQ,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,SAAS,iEAAiE,CAAC,CAAC,SAAS;CACxH,UAAUA,IAAAA,EAAE,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,CAAC,SAAS,iJAAiJ;CACxL,WAAWA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,2HAA2H;CAChK,aAAaA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,0FAA0F,CAAC,CAAC,SAAS;CACtI,8BAA8BA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,SAAS,iHAAiH,CAAC,CAAC,SAAS;AACrM,CAAC,CAAC,CAAC,SAAS,qEAAqE;AACjF,MAAM,oDAAoDA,IAAAA,EAAE,OAAO;CACjE,UAAUA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,uBAAuB,CAAC,CAAC,SAAS;CAChE,WAAWA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,0DAA0D,CAAC,CAAC,SAAS;AAC5G,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,+BAA+B;AACzD,MAAM,wEAAwEA,IAAAA,EAAE,OAAO;CACrF,IAAIA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,+DAA+D,CAAC,CAAC,SAAS;CACxG,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,yCAAyC,CAAC,CAAC,SAAS;CAC9E,OAAOA,IAAAA,EAAE,MAAM,iDAAiD,CAAC,CAAC,SAAS,4CAA4C;CACvH,SAASA,IAAAA,EAAE,QAAQ,CAAC,CAAC,SAAS,mCAAmC,CAAC,CAAC,SAAS;CAC5E,UAAUA,IAAAA,EAAE,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,CAAC,SAAS,iDAAiD;CACxF,aAAaA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,+CAA+C,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS;CACtG,8BAA8BA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,0DAA0D,CAAC,CAAC,SAAS;AAC/H,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,oDAAoD;AAC9E,MAAa,+CAA+CA,IAAAA,EAAE,OAAO,EACnE,4BAA4B,sEAAsE,SAAS,EAC7G,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,4DAA4D;AAEtF,MAAa,yCAAyCC,eAAAA,OAAO,+CAA+C;CAC1G,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAAO;CACP,QAAQ;AACV,CAAC"}

package/dist/actions/create-location-failure-condition.d.cts

@@ -1,9 +1,48 @@
 import { z } from "zod";
 
 //#region src/actions/create-location-failure-condition.d.ts
-declare const NewRelicCreateLocationFailureConditionInput: z.ZodTypeAny;
-declare const NewRelicCreateLocationFailureConditionOutput: z.ZodTypeAny;
-declare const newRelicCreateLocationFailureCondition: import("@keystrokehq/action").WorkflowActionDefinition<unknown, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
+declare const NewRelicCreateLocationFailureConditionInput: z.ZodObject<{
+  name: z.ZodString;
+  terms: z.ZodArray<z.ZodObject<{
+    priority: z.ZodEnum<{
+      critical: "critical";
+      warning: "warning";
+    }>;
+    threshold: z.ZodNumber;
+  }, z.core.$loose>>;
+  enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+  entities: z.ZodArray<z.ZodString>;
+  policy_id: z.ZodNumber;
+  runbook_url: z.ZodOptional<z.ZodString>;
+  violation_time_limit_seconds: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, z.core.$strip>;
+declare const NewRelicCreateLocationFailureConditionOutput: z.ZodObject<{
+  location_failure_condition: z.ZodNullable<z.ZodObject<{
+    id: z.ZodNullable<z.ZodNumber>;
+    name: z.ZodNullable<z.ZodString>;
+    terms: z.ZodArray<z.ZodObject<{
+      priority: z.ZodNullable<z.ZodString>;
+      threshold: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$loose>>;
+    enabled: z.ZodNullable<z.ZodBoolean>;
+    entities: z.ZodArray<z.ZodString>;
+    runbook_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    violation_time_limit_seconds: z.ZodNullable<z.ZodNumber>;
+  }, z.core.$loose>>;
+}, z.core.$loose>;
+declare const newRelicCreateLocationFailureCondition: import("@keystrokehq/action").WorkflowActionDefinition<{
+  name: string;
+  terms: {
+    [x: string]: unknown;
+    priority: "critical" | "warning";
+    threshold: number;
+  }[];
+  entities: string[];
+  policy_id: number;
+  enabled?: boolean | undefined;
+  runbook_url?: string | undefined;
+  violation_time_limit_seconds?: number | undefined;
+}, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
 //#endregion
 export { newRelicCreateLocationFailureCondition };
 //# sourceMappingURL=create-location-failure-condition.d.cts.map

package/dist/actions/create-location-failure-condition.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"create-location-failure-condition.d.cts","names":[],"sources":["../../src/actions/create-location-failure-condition.ts"],"mappings":";;;cAIa,2CAAA,EAA6C,CAAA,CAAE,UAWsB;AAAA,cAcrE,4CAAA,EAA8C,CAAA,CAAE,UAEY;AAAA,cAE5D,sCAAA,gCAAsC,wBAAA,iDAAA,mBAAA,yCAAA,UAAA,4CAAA,UAAA"}
+{"version":3,"file":"create-location-failure-condition.d.cts","names":[],"sources":["../../src/actions/create-location-failure-condition.ts"],"mappings":";;;cAIa,2CAAA,EAA2C,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;cAyB3C,4CAAA,EAA4C,CAAA,CAAA,SAAA;;;;;;;;;;;;;;cAI5C,sCAAA,gCAAsC,wBAAA"}

package/dist/actions/create-location-failure-condition.d.mts

@@ -1,9 +1,48 @@
 import { z } from "zod";
 
 //#region src/actions/create-location-failure-condition.d.ts
-declare const NewRelicCreateLocationFailureConditionInput: z.ZodTypeAny;
-declare const NewRelicCreateLocationFailureConditionOutput: z.ZodTypeAny;
-declare const newRelicCreateLocationFailureCondition: import("@keystrokehq/action").WorkflowActionDefinition<unknown, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
+declare const NewRelicCreateLocationFailureConditionInput: z.ZodObject<{
+  name: z.ZodString;
+  terms: z.ZodArray<z.ZodObject<{
+    priority: z.ZodEnum<{
+      critical: "critical";
+      warning: "warning";
+    }>;
+    threshold: z.ZodNumber;
+  }, z.core.$loose>>;
+  enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+  entities: z.ZodArray<z.ZodString>;
+  policy_id: z.ZodNumber;
+  runbook_url: z.ZodOptional<z.ZodString>;
+  violation_time_limit_seconds: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+}, z.core.$strip>;
+declare const NewRelicCreateLocationFailureConditionOutput: z.ZodObject<{
+  location_failure_condition: z.ZodNullable<z.ZodObject<{
+    id: z.ZodNullable<z.ZodNumber>;
+    name: z.ZodNullable<z.ZodString>;
+    terms: z.ZodArray<z.ZodObject<{
+      priority: z.ZodNullable<z.ZodString>;
+      threshold: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$loose>>;
+    enabled: z.ZodNullable<z.ZodBoolean>;
+    entities: z.ZodArray<z.ZodString>;
+    runbook_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    violation_time_limit_seconds: z.ZodNullable<z.ZodNumber>;
+  }, z.core.$loose>>;
+}, z.core.$loose>;
+declare const newRelicCreateLocationFailureCondition: import("@keystrokehq/action").WorkflowActionDefinition<{
+  name: string;
+  terms: {
+    [x: string]: unknown;
+    priority: "critical" | "warning";
+    threshold: number;
+  }[];
+  entities: string[];
+  policy_id: number;
+  enabled?: boolean | undefined;
+  runbook_url?: string | undefined;
+  violation_time_limit_seconds?: number | undefined;
+}, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
 //#endregion
 export { newRelicCreateLocationFailureCondition };
 //# sourceMappingURL=create-location-failure-condition.d.mts.map

package/dist/actions/create-location-failure-condition.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"create-location-failure-condition.d.mts","names":[],"sources":["../../src/actions/create-location-failure-condition.ts"],"mappings":";;;cAIa,2CAAA,EAA6C,CAAA,CAAE,UAWsB;AAAA,cAcrE,4CAAA,EAA8C,CAAA,CAAE,UAEY;AAAA,cAE5D,sCAAA,gCAAsC,wBAAA,iDAAA,mBAAA,yCAAA,UAAA,4CAAA,UAAA"}
+{"version":3,"file":"create-location-failure-condition.d.mts","names":[],"sources":["../../src/actions/create-location-failure-condition.ts"],"mappings":";;;cAIa,2CAAA,EAA2C,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;cAyB3C,4CAAA,EAA4C,CAAA,CAAA,SAAA;;;;;;;;;;;;;;cAI5C,sCAAA,gCAAsC,wBAAA"}

package/dist/actions/create-location-failure-condition.mjs

@@ -6,7 +6,7 @@ const NewRelicCreateLocationFailureConditionInput = z.object({
 	terms: z.array(z.object({
 		priority: z.enum(["critical", "warning"]).describe("Alert priority level. Critical alerts require immediate attention, warning alerts are informational."),
 		threshold: z.number().int().describe("Number of locations that must fail simultaneously to trigger the alert.")
-	}).describe("Threshold configuration for location failure condition.")).describe("Array of threshold objects that define when alerts are triggered based on number of failing locations."),
+	}).passthrough().describe("Threshold configuration for location failure condition.")).describe("Array of threshold objects that define when alerts are triggered based on number of failing locations."),
 	enabled: z.boolean().default(true).describe("Whether the alert condition is enabled and actively monitoring.").optional(),
 	entities: z.array(z.string()).describe("Array of synthetic monitor IDs (UUIDs) that this condition will monitor. Each ID represents a synthetic monitor to watch for location failures."),
 	policy_id: z.number().int().describe("The ID of the alert policy to attach this location failure condition to. The policy must exist in your New Relic account."),
@@ -14,24 +14,24 @@ const NewRelicCreateLocationFailureConditionInput = z.object({
 	violation_time_limit_seconds: z.number().int().default(86400).describe("How long in seconds an incident remains open before automatically closing. Default is 86400 seconds (24 hours).").optional()
 }).describe("Request parameters for creating a location failure alert condition.");
 const NewRelicCreateLocationFailureCondition_TermSchema = z.object({
-	priority: z.string().describe("Alert priority level."),
-	threshold: z.number().int().describe("Number of locations that must fail to trigger the alert.")
-}).describe("Term details in the response.");
+	priority: z.string().describe("Alert priority level.").nullable(),
+	threshold: z.number().int().describe("Number of locations that must fail to trigger the alert.").nullable()
+}).passthrough().describe("Term details in the response.");
 const NewRelicCreateLocationFailureCondition_LocationFailureConditionSchema = z.object({
-	id: z.number().int().describe("Unique identifier for the created location failure condition."),
-	name: z.string().describe("Name of the location failure condition."),
+	id: z.number().int().describe("Unique identifier for the created location failure condition.").nullable(),
+	name: z.string().describe("Name of the location failure condition.").nullable(),
 	terms: z.array(NewRelicCreateLocationFailureCondition_TermSchema).describe("List of threshold terms for the condition."),
-	enabled: z.boolean().describe("Whether the condition is enabled."),
+	enabled: z.boolean().describe("Whether the condition is enabled.").nullable(),
 	entities: z.array(z.string()).describe("Array of synthetic monitor IDs being monitored."),
 	runbook_url: z.string().describe("Optional URL to a runbook for this condition.").nullable().optional(),
-	violation_time_limit_seconds: z.number().int().describe("Maximum duration in seconds an incident can remain open.")
-}).describe("Details of the created location failure condition.");
+	violation_time_limit_seconds: z.number().int().describe("Maximum duration in seconds an incident can remain open.").nullable()
+}).passthrough().describe("Details of the created location failure condition.");
 const newRelicCreateLocationFailureCondition = action("NEW_RELIC_CREATE_LOCATION_FAILURE_CONDITION", {
 	slug: "new_relic-create-location-failure-condition",
 	name: "Create Location Failure Alert Condition",
 	description: "Tool to create a location failure alert condition in New Relic. Use when you need to monitor synthetic monitors and trigger alerts when multiple locations fail simultaneously.",
 	input: NewRelicCreateLocationFailureConditionInput,
-	output: z.object({ location_failure_condition: NewRelicCreateLocationFailureCondition_LocationFailureConditionSchema.nullable() }).describe("Response from creating a location failure alert condition.")
+	output: z.object({ location_failure_condition: NewRelicCreateLocationFailureCondition_LocationFailureConditionSchema.nullable() }).passthrough().describe("Response from creating a location failure alert condition.")
 });
 //#endregion
 export { newRelicCreateLocationFailureCondition };

package/dist/actions/create-location-failure-condition.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-location-failure-condition.mjs","names":[],"sources":["../../src/actions/create-location-failure-condition.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateLocationFailureConditionInput: z.ZodTypeAny = z.object({\n  name: z.string().describe(\"The name of the multi-location failure condition. Must be unique within the policy.\"),\n  terms: z.array(z.object({\n  priority: z.enum([\"critical\", \"warning\"]).describe(\"Alert priority level. Critical alerts require immediate attention, warning alerts are informational.\"),\n  threshold: z.number().int().describe(\"Number of locations that must fail simultaneously to trigger the alert.\"),\n}).describe(\"Threshold configuration for location failure condition.\")).describe(\"Array of threshold objects that define when alerts are triggered based on number of failing locations.\"),\n  enabled: z.boolean().default(true).describe(\"Whether the alert condition is enabled and actively monitoring.\").optional(),\n  entities: z.array(z.string()).describe(\"Array of synthetic monitor IDs (UUIDs) that this condition will monitor. Each ID represents a synthetic monitor to watch for location failures.\"),\n  policy_id: z.number().int().describe(\"The ID of the alert policy to attach this location failure condition to. The policy must exist in your New Relic account.\"),\n  runbook_url: z.string().describe(\"Optional URL to a runbook providing instructions for responding to this alert condition.\").optional(),\n  violation_time_limit_seconds: z.number().int().default(86400).describe(\"How long in seconds an incident remains open before automatically closing. Default is 86400 seconds (24 hours).\").optional(),\n}).describe(\"Request parameters for creating a location failure alert condition.\");\nconst NewRelicCreateLocationFailureCondition_TermSchema: z.ZodTypeAny = z.object({\n  priority: z.string().describe(\"Alert priority level.\"),\n  threshold: z.number().int().describe(\"Number of locations that must fail to trigger the alert.\"),\n}).describe(\"Term details in the response.\");\nconst NewRelicCreateLocationFailureCondition_LocationFailureConditionSchema: z.ZodTypeAny = z.object({\n  id: z.number().int().describe(\"Unique identifier for the created location failure condition.\"),\n  name: z.string().describe(\"Name of the location failure condition.\"),\n  terms: z.array(NewRelicCreateLocationFailureCondition_TermSchema).describe(\"List of threshold terms for the condition.\"),\n  enabled: z.boolean().describe(\"Whether the condition is enabled.\"),\n  entities: z.array(z.string()).describe(\"Array of synthetic monitor IDs being monitored.\"),\n  runbook_url: z.string().describe(\"Optional URL to a runbook for this condition.\").nullable().optional(),\n  violation_time_limit_seconds: z.number().int().describe(\"Maximum duration in seconds an incident can remain open.\"),\n}).describe(\"Details of the created location failure condition.\");\nexport const NewRelicCreateLocationFailureConditionOutput: z.ZodTypeAny = z.object({\n  location_failure_condition: NewRelicCreateLocationFailureCondition_LocationFailureConditionSchema.nullable(),\n}).describe(\"Response from creating a location failure alert condition.\");\n\nexport const newRelicCreateLocationFailureCondition = action(\"NEW_RELIC_CREATE_LOCATION_FAILURE_CONDITION\", {\n  slug: \"new_relic-create-location-failure-condition\",\n  name: \"Create Location Failure Alert Condition\",\n  description: \"Tool to create a location failure alert condition in New Relic. Use when you need to monitor synthetic monitors and trigger alerts when multiple locations fail simultaneously.\",\n  input: NewRelicCreateLocationFailureConditionInput,\n  output: NewRelicCreateLocationFailureConditionOutput,\n});\n"],"mappings":";;;AAIA,MAAa,8CAA4D,EAAE,OAAO;CAChF,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,qFAAqF;CAC/G,OAAO,EAAE,MAAM,EAAE,OAAO;EACxB,UAAU,EAAE,KAAK,CAAC,YAAY,SAAS,CAAC,CAAC,CAAC,SAAS,sGAAsG;EACzJ,WAAW,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,yEAAyE;CAChH,CAAC,CAAC,CAAC,SAAS,yDAAyD,CAAC,CAAC,CAAC,SAAS,wGAAwG;CACvL,SAAS,EAAE,QAAQ,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,SAAS,iEAAiE,CAAC,CAAC,SAAS;CACxH,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,SAAS,iJAAiJ;CACxL,WAAW,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,2HAA2H;CAChK,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS,0FAA0F,CAAC,CAAC,SAAS;CACtI,8BAA8B,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,SAAS,iHAAiH,CAAC,CAAC,SAAS;AACrM,CAAC,CAAC,CAAC,SAAS,qEAAqE;AACjF,MAAM,oDAAkE,EAAE,OAAO;CAC/E,UAAU,EAAE,OAAO,CAAC,CAAC,SAAS,uBAAuB;CACrD,WAAW,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,0DAA0D;AACjG,CAAC,CAAC,CAAC,SAAS,+BAA+B;AAC3C,MAAM,wEAAsF,EAAE,OAAO;CACnG,IAAI,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,+DAA+D;CAC7F,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,yCAAyC;CACnE,OAAO,EAAE,MAAM,iDAAiD,CAAC,CAAC,SAAS,4CAA4C;CACvH,SAAS,EAAE,QAAQ,CAAC,CAAC,SAAS,mCAAmC;CACjE,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,SAAS,iDAAiD;CACxF,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS,+CAA+C,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS;CACtG,8BAA8B,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,0DAA0D;AACpH,CAAC,CAAC,CAAC,SAAS,oDAAoD;AAKhE,MAAa,yCAAyC,OAAO,+CAA+C;CAC1G,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAAO;CACP,QATwE,EAAE,OAAO,EACjF,4BAA4B,sEAAsE,SAAS,EAC7G,CAAC,CAAC,CAAC,SAAS,4DAOF;AACV,CAAC"}
+{"version":3,"file":"create-location-failure-condition.mjs","names":[],"sources":["../../src/actions/create-location-failure-condition.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateLocationFailureConditionInput = z.object({\n  name: z.string().describe(\"The name of the multi-location failure condition. Must be unique within the policy.\"),\n  terms: z.array(z.object({\n  priority: z.enum([\"critical\", \"warning\"]).describe(\"Alert priority level. Critical alerts require immediate attention, warning alerts are informational.\"),\n  threshold: z.number().int().describe(\"Number of locations that must fail simultaneously to trigger the alert.\"),\n}).passthrough().describe(\"Threshold configuration for location failure condition.\")).describe(\"Array of threshold objects that define when alerts are triggered based on number of failing locations.\"),\n  enabled: z.boolean().default(true).describe(\"Whether the alert condition is enabled and actively monitoring.\").optional(),\n  entities: z.array(z.string()).describe(\"Array of synthetic monitor IDs (UUIDs) that this condition will monitor. Each ID represents a synthetic monitor to watch for location failures.\"),\n  policy_id: z.number().int().describe(\"The ID of the alert policy to attach this location failure condition to. The policy must exist in your New Relic account.\"),\n  runbook_url: z.string().describe(\"Optional URL to a runbook providing instructions for responding to this alert condition.\").optional(),\n  violation_time_limit_seconds: z.number().int().default(86400).describe(\"How long in seconds an incident remains open before automatically closing. Default is 86400 seconds (24 hours).\").optional(),\n}).describe(\"Request parameters for creating a location failure alert condition.\");\nconst NewRelicCreateLocationFailureCondition_TermSchema = z.object({\n  priority: z.string().describe(\"Alert priority level.\").nullable(),\n  threshold: z.number().int().describe(\"Number of locations that must fail to trigger the alert.\").nullable(),\n}).passthrough().describe(\"Term details in the response.\");\nconst NewRelicCreateLocationFailureCondition_LocationFailureConditionSchema = z.object({\n  id: z.number().int().describe(\"Unique identifier for the created location failure condition.\").nullable(),\n  name: z.string().describe(\"Name of the location failure condition.\").nullable(),\n  terms: z.array(NewRelicCreateLocationFailureCondition_TermSchema).describe(\"List of threshold terms for the condition.\"),\n  enabled: z.boolean().describe(\"Whether the condition is enabled.\").nullable(),\n  entities: z.array(z.string()).describe(\"Array of synthetic monitor IDs being monitored.\"),\n  runbook_url: z.string().describe(\"Optional URL to a runbook for this condition.\").nullable().optional(),\n  violation_time_limit_seconds: z.number().int().describe(\"Maximum duration in seconds an incident can remain open.\").nullable(),\n}).passthrough().describe(\"Details of the created location failure condition.\");\nexport const NewRelicCreateLocationFailureConditionOutput = z.object({\n  location_failure_condition: NewRelicCreateLocationFailureCondition_LocationFailureConditionSchema.nullable(),\n}).passthrough().describe(\"Response from creating a location failure alert condition.\");\n\nexport const newRelicCreateLocationFailureCondition = action(\"NEW_RELIC_CREATE_LOCATION_FAILURE_CONDITION\", {\n  slug: \"new_relic-create-location-failure-condition\",\n  name: \"Create Location Failure Alert Condition\",\n  description: \"Tool to create a location failure alert condition in New Relic. Use when you need to monitor synthetic monitors and trigger alerts when multiple locations fail simultaneously.\",\n  input: NewRelicCreateLocationFailureConditionInput,\n  output: NewRelicCreateLocationFailureConditionOutput,\n});\n"],"mappings":";;;AAIA,MAAa,8CAA8C,EAAE,OAAO;CAClE,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,qFAAqF;CAC/G,OAAO,EAAE,MAAM,EAAE,OAAO;EACxB,UAAU,EAAE,KAAK,CAAC,YAAY,SAAS,CAAC,CAAC,CAAC,SAAS,sGAAsG;EACzJ,WAAW,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,yEAAyE;CAChH,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,yDAAyD,CAAC,CAAC,CAAC,SAAS,wGAAwG;CACrM,SAAS,EAAE,QAAQ,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,SAAS,iEAAiE,CAAC,CAAC,SAAS;CACxH,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,SAAS,iJAAiJ;CACxL,WAAW,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,2HAA2H;CAChK,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS,0FAA0F,CAAC,CAAC,SAAS;CACtI,8BAA8B,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,SAAS,iHAAiH,CAAC,CAAC,SAAS;AACrM,CAAC,CAAC,CAAC,SAAS,qEAAqE;AACjF,MAAM,oDAAoD,EAAE,OAAO;CACjE,UAAU,EAAE,OAAO,CAAC,CAAC,SAAS,uBAAuB,CAAC,CAAC,SAAS;CAChE,WAAW,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,0DAA0D,CAAC,CAAC,SAAS;AAC5G,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,+BAA+B;AACzD,MAAM,wEAAwE,EAAE,OAAO;CACrF,IAAI,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,+DAA+D,CAAC,CAAC,SAAS;CACxG,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,yCAAyC,CAAC,CAAC,SAAS;CAC9E,OAAO,EAAE,MAAM,iDAAiD,CAAC,CAAC,SAAS,4CAA4C;CACvH,SAAS,EAAE,QAAQ,CAAC,CAAC,SAAS,mCAAmC,CAAC,CAAC,SAAS;CAC5E,UAAU,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,SAAS,iDAAiD;CACxF,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS,+CAA+C,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS;CACtG,8BAA8B,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,0DAA0D,CAAC,CAAC,SAAS;AAC/H,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,oDAAoD;AAK9E,MAAa,yCAAyC,OAAO,+CAA+C;CAC1G,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAAO;CACP,QAT0D,EAAE,OAAO,EACnE,4BAA4B,sEAAsE,SAAS,EAC7G,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,4DAOhB;AACV,CAAC"}

package/dist/actions/create-log-data-partition-rule.cjs

@@ -10,19 +10,19 @@ const NewRelicCreateLogDataPartitionRuleInput = zod.z.object({
 	target_data_partition: zod.z.string().describe("Name of the target data partition where matching logs will be routed. Must start with 'Log_'.")
 }).describe("Request parameters for creating a log data partition rule via NerdGraph GraphQL API.");
 const NewRelicCreateLogDataPartitionRule_CreatedDataPartitionRuleSchema = zod.z.object({
-	id: zod.z.string().describe("Unique identifier of the created data partition rule."),
-	enabled: zod.z.boolean().describe("Whether the rule is enabled."),
-	description: zod.z.string().describe("Description of the data partition rule."),
-	target_data_partition: zod.z.string().describe("Name of the target data partition.")
-}).describe("Details of the created data partition rule.");
+	id: zod.z.string().describe("Unique identifier of the created data partition rule.").nullable(),
+	enabled: zod.z.boolean().describe("Whether the rule is enabled.").nullable(),
+	description: zod.z.string().describe("Description of the data partition rule.").nullable(),
+	target_data_partition: zod.z.string().describe("Name of the target data partition.").nullable()
+}).passthrough().describe("Details of the created data partition rule.");
 const NewRelicCreateLogDataPartitionRule_DataPartitionRuleErrorSchema = zod.z.object({
-	type: zod.z.string().describe("Type or classification of the error."),
-	message: zod.z.string().describe("Error message describing what went wrong.")
-}).describe("Error details from the GraphQL mutation.");
+	type: zod.z.string().describe("Type or classification of the error.").nullable(),
+	message: zod.z.string().describe("Error message describing what went wrong.").nullable()
+}).passthrough().describe("Error details from the GraphQL mutation.");
 const NewRelicCreateLogDataPartitionRuleOutput = zod.z.object({
 	rule: NewRelicCreateLogDataPartitionRule_CreatedDataPartitionRuleSchema.nullable().optional(),
 	errors: zod.z.array(NewRelicCreateLogDataPartitionRule_DataPartitionRuleErrorSchema).describe("List of errors if the mutation encountered issues.").nullable().optional()
-}).describe("Response from creating a log data partition rule via NerdGraph GraphQL API.");
+}).passthrough().describe("Response from creating a log data partition rule via NerdGraph GraphQL API.");
 const newRelicCreateLogDataPartitionRule = require_action.action("NEW_RELIC_CREATE_LOG_DATA_PARTITION_RULE", {
 	slug: "new_relic-create-log-data-partition-rule",
 	name: "Create Log Data Partition Rule",

package/dist/actions/create-log-data-partition-rule.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-log-data-partition-rule.cjs","names":["z","action"],"sources":["../../src/actions/create-log-data-partition-rule.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateLogDataPartitionRuleInput: z.ZodTypeAny = z.object({\n  nrql: z.string().describe(\"NRQL WHERE clause defining the matching criteria for routing logs to this partition. Do not include the 'WHERE' keyword.\"),\n  enabled: z.boolean().describe(\"Whether the data partition rule is active and will route matching logs.\"),\n  account_id: z.number().int().describe(\"The New Relic account ID where the data partition rule will be created.\"),\n  description: z.string().describe(\"Description explaining the purpose of this data partition rule.\"),\n  retention_policy: z.enum([\"STANDARD\", \"SECONDARY\"]).describe(\"Data retention policy. STANDARD: account's default retention based on subscription. SECONDARY: 30-day rolling retention.\"),\n  target_data_partition: z.string().describe(\"Name of the target data partition where matching logs will be routed. Must start with 'Log_'.\"),\n}).describe(\"Request parameters for creating a log data partition rule via NerdGraph GraphQL API.\");\nconst NewRelicCreateLogDataPartitionRule_CreatedDataPartitionRuleSchema: z.ZodTypeAny = z.object({\n  id: z.string().describe(\"Unique identifier of the created data partition rule.\"),\n  enabled: z.boolean().describe(\"Whether the rule is enabled.\"),\n  description: z.string().describe(\"Description of the data partition rule.\"),\n  target_data_partition: z.string().describe(\"Name of the target data partition.\"),\n}).describe(\"Details of the created data partition rule.\");\nconst NewRelicCreateLogDataPartitionRule_DataPartitionRuleErrorSchema: z.ZodTypeAny = z.object({\n  type: z.string().describe(\"Type or classification of the error.\"),\n  message: z.string().describe(\"Error message describing what went wrong.\"),\n}).describe(\"Error details from the GraphQL mutation.\");\nexport const NewRelicCreateLogDataPartitionRuleOutput: z.ZodTypeAny = z.object({\n  rule: NewRelicCreateLogDataPartitionRule_CreatedDataPartitionRuleSchema.nullable().optional(),\n  errors: z.array(NewRelicCreateLogDataPartitionRule_DataPartitionRuleErrorSchema).describe(\"List of errors if the mutation encountered issues.\").nullable().optional(),\n}).describe(\"Response from creating a log data partition rule via NerdGraph GraphQL API.\");\n\nexport const newRelicCreateLogDataPartitionRule = action(\"NEW_RELIC_CREATE_LOG_DATA_PARTITION_RULE\", {\n  slug: \"new_relic-create-log-data-partition-rule\",\n  name: \"Create Log Data Partition Rule\",\n  description: \"Tool to create a log data partition rule using New Relic's NerdGraph GraphQL API. Use when you need to route logs to specific partitions based on matching criteria for better organization and retention management.\",\n  input: NewRelicCreateLogDataPartitionRuleInput,\n  output: NewRelicCreateLogDataPartitionRuleOutput,\n});\n"],"mappings":";;;AAIA,MAAa,0CAAwDA,IAAAA,EAAE,OAAO;CAC5E,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,0HAA0H;CACpJ,SAASA,IAAAA,EAAE,QAAQ,CAAC,CAAC,SAAS,yEAAyE;CACvG,YAAYA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,yEAAyE;CAC/G,aAAaA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,iEAAiE;CAClG,kBAAkBA,IAAAA,EAAE,KAAK,CAAC,YAAY,WAAW,CAAC,CAAC,CAAC,SAAS,0HAA0H;CACvL,uBAAuBA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,+FAA+F;AAC5I,CAAC,CAAC,CAAC,SAAS,sFAAsF;AAClG,MAAM,oEAAkFA,IAAAA,EAAE,OAAO;CAC/F,IAAIA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,uDAAuD;CAC/E,SAASA,IAAAA,EAAE,QAAQ,CAAC,CAAC,SAAS,8BAA8B;CAC5D,aAAaA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,yCAAyC;CAC1E,uBAAuBA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,oCAAoC;AACjF,CAAC,CAAC,CAAC,SAAS,6CAA6C;AACzD,MAAM,kEAAgFA,IAAAA,EAAE,OAAO;CAC7F,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,sCAAsC;CAChE,SAASA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,2CAA2C;AAC1E,CAAC,CAAC,CAAC,SAAS,0CAA0C;AACtD,MAAa,2CAAyDA,IAAAA,EAAE,OAAO;CAC7E,MAAM,kEAAkE,SAAS,CAAC,CAAC,SAAS;CAC5F,QAAQA,IAAAA,EAAE,MAAM,+DAA+D,CAAC,CAAC,SAAS,oDAAoD,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS;AACtK,CAAC,CAAC,CAAC,SAAS,6EAA6E;AAEzF,MAAa,qCAAqCC,eAAAA,OAAO,4CAA4C;CACnG,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAAO;CACP,QAAQ;AACV,CAAC"}
+{"version":3,"file":"create-log-data-partition-rule.cjs","names":["z","action"],"sources":["../../src/actions/create-log-data-partition-rule.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateLogDataPartitionRuleInput = z.object({\n  nrql: z.string().describe(\"NRQL WHERE clause defining the matching criteria for routing logs to this partition. Do not include the 'WHERE' keyword.\"),\n  enabled: z.boolean().describe(\"Whether the data partition rule is active and will route matching logs.\"),\n  account_id: z.number().int().describe(\"The New Relic account ID where the data partition rule will be created.\"),\n  description: z.string().describe(\"Description explaining the purpose of this data partition rule.\"),\n  retention_policy: z.enum([\"STANDARD\", \"SECONDARY\"]).describe(\"Data retention policy. STANDARD: account's default retention based on subscription. SECONDARY: 30-day rolling retention.\"),\n  target_data_partition: z.string().describe(\"Name of the target data partition where matching logs will be routed. Must start with 'Log_'.\"),\n}).describe(\"Request parameters for creating a log data partition rule via NerdGraph GraphQL API.\");\nconst NewRelicCreateLogDataPartitionRule_CreatedDataPartitionRuleSchema = z.object({\n  id: z.string().describe(\"Unique identifier of the created data partition rule.\").nullable(),\n  enabled: z.boolean().describe(\"Whether the rule is enabled.\").nullable(),\n  description: z.string().describe(\"Description of the data partition rule.\").nullable(),\n  target_data_partition: z.string().describe(\"Name of the target data partition.\").nullable(),\n}).passthrough().describe(\"Details of the created data partition rule.\");\nconst NewRelicCreateLogDataPartitionRule_DataPartitionRuleErrorSchema = z.object({\n  type: z.string().describe(\"Type or classification of the error.\").nullable(),\n  message: z.string().describe(\"Error message describing what went wrong.\").nullable(),\n}).passthrough().describe(\"Error details from the GraphQL mutation.\");\nexport const NewRelicCreateLogDataPartitionRuleOutput = z.object({\n  rule: NewRelicCreateLogDataPartitionRule_CreatedDataPartitionRuleSchema.nullable().optional(),\n  errors: z.array(NewRelicCreateLogDataPartitionRule_DataPartitionRuleErrorSchema).describe(\"List of errors if the mutation encountered issues.\").nullable().optional(),\n}).passthrough().describe(\"Response from creating a log data partition rule via NerdGraph GraphQL API.\");\n\nexport const newRelicCreateLogDataPartitionRule = action(\"NEW_RELIC_CREATE_LOG_DATA_PARTITION_RULE\", {\n  slug: \"new_relic-create-log-data-partition-rule\",\n  name: \"Create Log Data Partition Rule\",\n  description: \"Tool to create a log data partition rule using New Relic's NerdGraph GraphQL API. Use when you need to route logs to specific partitions based on matching criteria for better organization and retention management.\",\n  input: NewRelicCreateLogDataPartitionRuleInput,\n  output: NewRelicCreateLogDataPartitionRuleOutput,\n});\n"],"mappings":";;;AAIA,MAAa,0CAA0CA,IAAAA,EAAE,OAAO;CAC9D,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,0HAA0H;CACpJ,SAASA,IAAAA,EAAE,QAAQ,CAAC,CAAC,SAAS,yEAAyE;CACvG,YAAYA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,yEAAyE;CAC/G,aAAaA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,iEAAiE;CAClG,kBAAkBA,IAAAA,EAAE,KAAK,CAAC,YAAY,WAAW,CAAC,CAAC,CAAC,SAAS,0HAA0H;CACvL,uBAAuBA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,+FAA+F;AAC5I,CAAC,CAAC,CAAC,SAAS,sFAAsF;AAClG,MAAM,oEAAoEA,IAAAA,EAAE,OAAO;CACjF,IAAIA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,uDAAuD,CAAC,CAAC,SAAS;CAC1F,SAASA,IAAAA,EAAE,QAAQ,CAAC,CAAC,SAAS,8BAA8B,CAAC,CAAC,SAAS;CACvE,aAAaA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,yCAAyC,CAAC,CAAC,SAAS;CACrF,uBAAuBA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,oCAAoC,CAAC,CAAC,SAAS;AAC5F,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,6CAA6C;AACvE,MAAM,kEAAkEA,IAAAA,EAAE,OAAO;CAC/E,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,sCAAsC,CAAC,CAAC,SAAS;CAC3E,SAASA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,2CAA2C,CAAC,CAAC,SAAS;AACrF,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,0CAA0C;AACpE,MAAa,2CAA2CA,IAAAA,EAAE,OAAO;CAC/D,MAAM,kEAAkE,SAAS,CAAC,CAAC,SAAS;CAC5F,QAAQA,IAAAA,EAAE,MAAM,+DAA+D,CAAC,CAAC,SAAS,oDAAoD,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS;AACtK,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,SAAS,6EAA6E;AAEvG,MAAa,qCAAqCC,eAAAA,OAAO,4CAA4C;CACnG,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAAO;CACP,QAAQ;AACV,CAAC"}

package/dist/actions/create-log-data-partition-rule.d.cts

@@ -1,9 +1,37 @@
 import { z } from "zod";
 
 //#region src/actions/create-log-data-partition-rule.d.ts
-declare const NewRelicCreateLogDataPartitionRuleInput: z.ZodTypeAny;
-declare const NewRelicCreateLogDataPartitionRuleOutput: z.ZodTypeAny;
-declare const newRelicCreateLogDataPartitionRule: import("@keystrokehq/action").WorkflowActionDefinition<unknown, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
+declare const NewRelicCreateLogDataPartitionRuleInput: z.ZodObject<{
+  nrql: z.ZodString;
+  enabled: z.ZodBoolean;
+  account_id: z.ZodNumber;
+  description: z.ZodString;
+  retention_policy: z.ZodEnum<{
+    STANDARD: "STANDARD";
+    SECONDARY: "SECONDARY";
+  }>;
+  target_data_partition: z.ZodString;
+}, z.core.$strip>;
+declare const NewRelicCreateLogDataPartitionRuleOutput: z.ZodObject<{
+  rule: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    id: z.ZodNullable<z.ZodString>;
+    enabled: z.ZodNullable<z.ZodBoolean>;
+    description: z.ZodNullable<z.ZodString>;
+    target_data_partition: z.ZodNullable<z.ZodString>;
+  }, z.core.$loose>>>;
+  errors: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+    type: z.ZodNullable<z.ZodString>;
+    message: z.ZodNullable<z.ZodString>;
+  }, z.core.$loose>>>>;
+}, z.core.$loose>;
+declare const newRelicCreateLogDataPartitionRule: import("@keystrokehq/action").WorkflowActionDefinition<{
+  nrql: string;
+  enabled: boolean;
+  account_id: number;
+  description: string;
+  retention_policy: "STANDARD" | "SECONDARY";
+  target_data_partition: string;
+}, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
 //#endregion
 export { newRelicCreateLogDataPartitionRule };
 //# sourceMappingURL=create-log-data-partition-rule.d.cts.map

package/dist/actions/create-log-data-partition-rule.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"create-log-data-partition-rule.d.cts","names":[],"sources":["../../src/actions/create-log-data-partition-rule.ts"],"mappings":";;;cAIa,uCAAA,EAAyC,CAAA,CAAE,UAO2C;AAAA,cAWtF,wCAAA,EAA0C,CAAA,CAAE,UAGiC;AAAA,cAE7E,kCAAA,gCAAkC,wBAAA,iDAAA,mBAAA,yCAAA,UAAA,4CAAA,UAAA"}
+{"version":3,"file":"create-log-data-partition-rule.d.cts","names":[],"sources":["../../src/actions/create-log-data-partition-rule.ts"],"mappings":";;;cAIa,uCAAA,EAAuC,CAAA,CAAA,SAAA;;;;;;;;;;;cAkBvC,wCAAA,EAAwC,CAAA,CAAA,SAAA;;;;;;;;;;;;cAKxC,kCAAA,gCAAkC,wBAAA"}