@keystrokehq/new_relic 0.1.0 → 0.1.2

package/dist/actions/create-alert-policy.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-alert-policy.cjs","names":["z","action"],"sources":["../../src/actions/create-alert-policy.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateAlertPolicyInput: z.ZodTypeAny = z.object({\n  name: z.string().describe(\"The name of the alert policy. Must be unique within the account.\"),\n  incident_preference: z.enum([\"PER_POLICY\", \"PER_CONDITION\", \"PER_CONDITION_AND_TARGET\"]).default(\"PER_POLICY\").describe(\"Determines how incidents are grouped. PER_POLICY: one issue per policy (recommended for most use cases). PER_CONDITION: one issue per alert condition. PER_CONDITION_AND_TARGET: one issue per condition and signal/target.\").optional(),\n});\nconst NewRelicCreateAlertPolicy_LinksSchema: z.ZodTypeAny = z.object({\n  conditions: z.array(z.number().int()).describe(\"A list of condition IDs associated with the policy.\").nullable().optional(),\n});\nconst NewRelicCreateAlertPolicy_PolicySchema: z.ZodTypeAny = z.object({\n  id: z.number().int().describe(\"Unique ID of the alert policy.\"),\n  name: z.string().describe(\"The name of the alert policy.\"),\n  links: NewRelicCreateAlertPolicy_LinksSchema.nullable().optional(),\n  created_at: z.number().int().describe(\"Timestamp (in milliseconds since epoch) when the alert policy was created.\"),\n  updated_at: z.number().int().describe(\"Timestamp (in milliseconds since epoch) when the alert policy was last updated.\"),\n  incident_preference: z.string().describe(\"Incident preference setting. One of: PER_POLICY, PER_CONDITION, or PER_CONDITION_AND_TARGET.\"),\n});\nexport const NewRelicCreateAlertPolicyOutput: z.ZodTypeAny = z.object({\n  policy: NewRelicCreateAlertPolicy_PolicySchema.nullable(),\n});\n\nexport const newRelicCreateAlertPolicy = action(\"NEW_RELIC_CREATE_ALERT_POLICY\", {\n  slug: \"new_relic-create-alert-policy\",\n  name: \"Create Alert Policy\",\n  description: \"Creates a new alert policy in New Relic. Alert policies are containers for alert conditions and define how incidents are grouped. Use this to set up monitoring thresholds and notification rules for your applications.\",\n  input: NewRelicCreateAlertPolicyInput,\n  output: NewRelicCreateAlertPolicyOutput,\n});\n"],"mappings":";;;AAIA,MAAa,iCAA+CA,IAAAA,EAAE,OAAO;CACnE,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,kEAAkE;CAC5F,qBAAqBA,IAAAA,EAAE,KAAK;EAAC;EAAc;EAAiB;CAA0B,CAAC,CAAC,CAAC,QAAQ,YAAY,CAAC,CAAC,SAAS,6NAA6N,CAAC,CAAC,SAAS;AAClW,CAAC;AACD,MAAM,wCAAsDA,IAAAA,EAAE,OAAO,EACnE,YAAYA,IAAAA,EAAE,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,qDAAqD,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,EAC5H,CAAC;AACD,MAAM,yCAAuDA,IAAAA,EAAE,OAAO;CACpE,IAAIA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,gCAAgC;CAC9D,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,+BAA+B;CACzD,OAAO,sCAAsC,SAAS,CAAC,CAAC,SAAS;CACjE,YAAYA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,4EAA4E;CAClH,YAAYA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,iFAAiF;CACvH,qBAAqBA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,8FAA8F;AACzI,CAAC;AACD,MAAa,kCAAgDA,IAAAA,EAAE,OAAO,EACpE,QAAQ,uCAAuC,SAAS,EAC1D,CAAC;AAED,MAAa,4BAA4BC,eAAAA,OAAO,iCAAiC;CAC/E,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAAO;CACP,QAAQ;AACV,CAAC"}
+{"version":3,"file":"create-alert-policy.cjs","names":["z","action"],"sources":["../../src/actions/create-alert-policy.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateAlertPolicyInput = z.object({\n  name: z.string().describe(\"The name of the alert policy. Must be unique within the account.\"),\n  incident_preference: z.enum([\"PER_POLICY\", \"PER_CONDITION\", \"PER_CONDITION_AND_TARGET\"]).default(\"PER_POLICY\").describe(\"Determines how incidents are grouped. PER_POLICY: one issue per policy (recommended for most use cases). PER_CONDITION: one issue per alert condition. PER_CONDITION_AND_TARGET: one issue per condition and signal/target.\").optional(),\n});\nconst NewRelicCreateAlertPolicy_LinksSchema = z.object({\n  conditions: z.array(z.number().int()).describe(\"A list of condition IDs associated with the policy.\").nullable().optional(),\n});\nconst NewRelicCreateAlertPolicy_PolicySchema = z.object({\n  id: z.number().int().describe(\"Unique ID of the alert policy.\").nullable(),\n  name: z.string().describe(\"The name of the alert policy.\").nullable(),\n  links: NewRelicCreateAlertPolicy_LinksSchema.nullable().optional(),\n  created_at: z.number().int().describe(\"Timestamp (in milliseconds since epoch) when the alert policy was created.\").nullable(),\n  updated_at: z.number().int().describe(\"Timestamp (in milliseconds since epoch) when the alert policy was last updated.\").nullable(),\n  incident_preference: z.string().describe(\"Incident preference setting. One of: PER_POLICY, PER_CONDITION, or PER_CONDITION_AND_TARGET.\").nullable(),\n});\nexport const NewRelicCreateAlertPolicyOutput = z.object({\n  policy: NewRelicCreateAlertPolicy_PolicySchema.nullable(),\n});\n\nexport const newRelicCreateAlertPolicy = action(\"NEW_RELIC_CREATE_ALERT_POLICY\", {\n  slug: \"new_relic-create-alert-policy\",\n  name: \"Create Alert Policy\",\n  description: \"Creates a new alert policy in New Relic. Alert policies are containers for alert conditions and define how incidents are grouped. Use this to set up monitoring thresholds and notification rules for your applications.\",\n  input: NewRelicCreateAlertPolicyInput,\n  output: NewRelicCreateAlertPolicyOutput,\n});\n"],"mappings":";;;AAIA,MAAa,iCAAiCA,IAAAA,EAAE,OAAO;CACrD,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,kEAAkE;CAC5F,qBAAqBA,IAAAA,EAAE,KAAK;EAAC;EAAc;EAAiB;CAA0B,CAAC,CAAC,CAAC,QAAQ,YAAY,CAAC,CAAC,SAAS,6NAA6N,CAAC,CAAC,SAAS;AAClW,CAAC;AACD,MAAM,wCAAwCA,IAAAA,EAAE,OAAO,EACrD,YAAYA,IAAAA,EAAE,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,qDAAqD,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,EAC5H,CAAC;AACD,MAAM,yCAAyCA,IAAAA,EAAE,OAAO;CACtD,IAAIA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,gCAAgC,CAAC,CAAC,SAAS;CACzE,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,+BAA+B,CAAC,CAAC,SAAS;CACpE,OAAO,sCAAsC,SAAS,CAAC,CAAC,SAAS;CACjE,YAAYA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,4EAA4E,CAAC,CAAC,SAAS;CAC7H,YAAYA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,iFAAiF,CAAC,CAAC,SAAS;CAClI,qBAAqBA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,8FAA8F,CAAC,CAAC,SAAS;AACpJ,CAAC;AACD,MAAa,kCAAkCA,IAAAA,EAAE,OAAO,EACtD,QAAQ,uCAAuC,SAAS,EAC1D,CAAC;AAED,MAAa,4BAA4BC,eAAAA,OAAO,iCAAiC;CAC/E,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAAO;CACP,QAAQ;AACV,CAAC"}

package/dist/actions/create-alert-policy.d.cts

@@ -1,9 +1,30 @@
 import { z } from "zod";
 
 //#region src/actions/create-alert-policy.d.ts
-declare const NewRelicCreateAlertPolicyInput: z.ZodTypeAny;
-declare const NewRelicCreateAlertPolicyOutput: z.ZodTypeAny;
-declare const newRelicCreateAlertPolicy: import("@keystrokehq/action").WorkflowActionDefinition<unknown, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
+declare const NewRelicCreateAlertPolicyInput: z.ZodObject<{
+  name: z.ZodString;
+  incident_preference: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+    PER_POLICY: "PER_POLICY";
+    PER_CONDITION: "PER_CONDITION";
+    PER_CONDITION_AND_TARGET: "PER_CONDITION_AND_TARGET";
+  }>>>;
+}, z.core.$strip>;
+declare const NewRelicCreateAlertPolicyOutput: z.ZodObject<{
+  policy: z.ZodNullable<z.ZodObject<{
+    id: z.ZodNullable<z.ZodNumber>;
+    name: z.ZodNullable<z.ZodString>;
+    links: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+      conditions: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber>>>;
+    }, z.core.$strip>>>;
+    created_at: z.ZodNullable<z.ZodNumber>;
+    updated_at: z.ZodNullable<z.ZodNumber>;
+    incident_preference: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const newRelicCreateAlertPolicy: import("@keystrokehq/action").WorkflowActionDefinition<{
+  name: string;
+  incident_preference?: "PER_POLICY" | "PER_CONDITION" | "PER_CONDITION_AND_TARGET" | undefined;
+}, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
 //#endregion
 export { newRelicCreateAlertPolicy };
 //# sourceMappingURL=create-alert-policy.d.cts.map

package/dist/actions/create-alert-policy.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"create-alert-policy.d.cts","names":[],"sources":["../../src/actions/create-alert-policy.ts"],"mappings":";;;cAIa,8BAAA,EAAgC,CAAA,CAAE,UAG7C;AAAA,cAYW,+BAAA,EAAiC,CAAA,CAAE,UAE9C;AAAA,cAEW,yBAAA,gCAAyB,wBAAA,iDAAA,mBAAA,yCAAA,UAAA,4CAAA,UAAA"}
+{"version":3,"file":"create-alert-policy.d.cts","names":[],"sources":["../../src/actions/create-alert-policy.ts"],"mappings":";;;cAIa,8BAAA,EAA8B,CAAA,CAAA,SAAA;;;;;;;;cAe9B,+BAAA,EAA+B,CAAA,CAAA,SAAA;;;;;;;;;;;;cAI/B,yBAAA,gCAAyB,wBAAA"}

package/dist/actions/create-alert-policy.d.mts

@@ -1,9 +1,30 @@
 import { z } from "zod";
 
 //#region src/actions/create-alert-policy.d.ts
-declare const NewRelicCreateAlertPolicyInput: z.ZodTypeAny;
-declare const NewRelicCreateAlertPolicyOutput: z.ZodTypeAny;
-declare const newRelicCreateAlertPolicy: import("@keystrokehq/action").WorkflowActionDefinition<unknown, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
+declare const NewRelicCreateAlertPolicyInput: z.ZodObject<{
+  name: z.ZodString;
+  incident_preference: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+    PER_POLICY: "PER_POLICY";
+    PER_CONDITION: "PER_CONDITION";
+    PER_CONDITION_AND_TARGET: "PER_CONDITION_AND_TARGET";
+  }>>>;
+}, z.core.$strip>;
+declare const NewRelicCreateAlertPolicyOutput: z.ZodObject<{
+  policy: z.ZodNullable<z.ZodObject<{
+    id: z.ZodNullable<z.ZodNumber>;
+    name: z.ZodNullable<z.ZodString>;
+    links: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+      conditions: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodNumber>>>;
+    }, z.core.$strip>>>;
+    created_at: z.ZodNullable<z.ZodNumber>;
+    updated_at: z.ZodNullable<z.ZodNumber>;
+    incident_preference: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const newRelicCreateAlertPolicy: import("@keystrokehq/action").WorkflowActionDefinition<{
+  name: string;
+  incident_preference?: "PER_POLICY" | "PER_CONDITION" | "PER_CONDITION_AND_TARGET" | undefined;
+}, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
 //#endregion
 export { newRelicCreateAlertPolicy };
 //# sourceMappingURL=create-alert-policy.d.mts.map

package/dist/actions/create-alert-policy.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"create-alert-policy.d.mts","names":[],"sources":["../../src/actions/create-alert-policy.ts"],"mappings":";;;cAIa,8BAAA,EAAgC,CAAA,CAAE,UAG7C;AAAA,cAYW,+BAAA,EAAiC,CAAA,CAAE,UAE9C;AAAA,cAEW,yBAAA,gCAAyB,wBAAA,iDAAA,mBAAA,yCAAA,UAAA,4CAAA,UAAA"}
+{"version":3,"file":"create-alert-policy.d.mts","names":[],"sources":["../../src/actions/create-alert-policy.ts"],"mappings":";;;cAIa,8BAAA,EAA8B,CAAA,CAAA,SAAA;;;;;;;;cAe9B,+BAAA,EAA+B,CAAA,CAAA,SAAA;;;;;;;;;;;;cAI/B,yBAAA,gCAAyB,wBAAA"}

package/dist/actions/create-alert-policy.mjs

@@ -11,12 +11,12 @@ const NewRelicCreateAlertPolicyInput = z.object({
 });
 const NewRelicCreateAlertPolicy_LinksSchema = z.object({ conditions: z.array(z.number().int()).describe("A list of condition IDs associated with the policy.").nullable().optional() });
 const NewRelicCreateAlertPolicy_PolicySchema = z.object({
-	id: z.number().int().describe("Unique ID of the alert policy."),
-	name: z.string().describe("The name of the alert policy."),
+	id: z.number().int().describe("Unique ID of the alert policy.").nullable(),
+	name: z.string().describe("The name of the alert policy.").nullable(),
 	links: NewRelicCreateAlertPolicy_LinksSchema.nullable().optional(),
-	created_at: z.number().int().describe("Timestamp (in milliseconds since epoch) when the alert policy was created."),
-	updated_at: z.number().int().describe("Timestamp (in milliseconds since epoch) when the alert policy was last updated."),
-	incident_preference: z.string().describe("Incident preference setting. One of: PER_POLICY, PER_CONDITION, or PER_CONDITION_AND_TARGET.")
+	created_at: z.number().int().describe("Timestamp (in milliseconds since epoch) when the alert policy was created.").nullable(),
+	updated_at: z.number().int().describe("Timestamp (in milliseconds since epoch) when the alert policy was last updated.").nullable(),
+	incident_preference: z.string().describe("Incident preference setting. One of: PER_POLICY, PER_CONDITION, or PER_CONDITION_AND_TARGET.").nullable()
 });
 const newRelicCreateAlertPolicy = action("NEW_RELIC_CREATE_ALERT_POLICY", {
 	slug: "new_relic-create-alert-policy",

package/dist/actions/create-alert-policy.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-alert-policy.mjs","names":[],"sources":["../../src/actions/create-alert-policy.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateAlertPolicyInput: z.ZodTypeAny = z.object({\n  name: z.string().describe(\"The name of the alert policy. Must be unique within the account.\"),\n  incident_preference: z.enum([\"PER_POLICY\", \"PER_CONDITION\", \"PER_CONDITION_AND_TARGET\"]).default(\"PER_POLICY\").describe(\"Determines how incidents are grouped. PER_POLICY: one issue per policy (recommended for most use cases). PER_CONDITION: one issue per alert condition. PER_CONDITION_AND_TARGET: one issue per condition and signal/target.\").optional(),\n});\nconst NewRelicCreateAlertPolicy_LinksSchema: z.ZodTypeAny = z.object({\n  conditions: z.array(z.number().int()).describe(\"A list of condition IDs associated with the policy.\").nullable().optional(),\n});\nconst NewRelicCreateAlertPolicy_PolicySchema: z.ZodTypeAny = z.object({\n  id: z.number().int().describe(\"Unique ID of the alert policy.\"),\n  name: z.string().describe(\"The name of the alert policy.\"),\n  links: NewRelicCreateAlertPolicy_LinksSchema.nullable().optional(),\n  created_at: z.number().int().describe(\"Timestamp (in milliseconds since epoch) when the alert policy was created.\"),\n  updated_at: z.number().int().describe(\"Timestamp (in milliseconds since epoch) when the alert policy was last updated.\"),\n  incident_preference: z.string().describe(\"Incident preference setting. One of: PER_POLICY, PER_CONDITION, or PER_CONDITION_AND_TARGET.\"),\n});\nexport const NewRelicCreateAlertPolicyOutput: z.ZodTypeAny = z.object({\n  policy: NewRelicCreateAlertPolicy_PolicySchema.nullable(),\n});\n\nexport const newRelicCreateAlertPolicy = action(\"NEW_RELIC_CREATE_ALERT_POLICY\", {\n  slug: \"new_relic-create-alert-policy\",\n  name: \"Create Alert Policy\",\n  description: \"Creates a new alert policy in New Relic. Alert policies are containers for alert conditions and define how incidents are grouped. Use this to set up monitoring thresholds and notification rules for your applications.\",\n  input: NewRelicCreateAlertPolicyInput,\n  output: NewRelicCreateAlertPolicyOutput,\n});\n"],"mappings":";;;AAIA,MAAa,iCAA+C,EAAE,OAAO;CACnE,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,kEAAkE;CAC5F,qBAAqB,EAAE,KAAK;EAAC;EAAc;EAAiB;CAA0B,CAAC,CAAC,CAAC,QAAQ,YAAY,CAAC,CAAC,SAAS,6NAA6N,CAAC,CAAC,SAAS;AAClW,CAAC;AACD,MAAM,wCAAsD,EAAE,OAAO,EACnE,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,qDAAqD,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,EAC5H,CAAC;AACD,MAAM,yCAAuD,EAAE,OAAO;CACpE,IAAI,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,gCAAgC;CAC9D,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,+BAA+B;CACzD,OAAO,sCAAsC,SAAS,CAAC,CAAC,SAAS;CACjE,YAAY,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,4EAA4E;CAClH,YAAY,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,iFAAiF;CACvH,qBAAqB,EAAE,OAAO,CAAC,CAAC,SAAS,8FAA8F;AACzI,CAAC;AAKD,MAAa,4BAA4B,OAAO,iCAAiC;CAC/E,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAAO;CACP,QAT2D,EAAE,OAAO,EACpE,QAAQ,uCAAuC,SAAS,EAC1D,CAOU;AACV,CAAC"}
+{"version":3,"file":"create-alert-policy.mjs","names":[],"sources":["../../src/actions/create-alert-policy.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateAlertPolicyInput = z.object({\n  name: z.string().describe(\"The name of the alert policy. Must be unique within the account.\"),\n  incident_preference: z.enum([\"PER_POLICY\", \"PER_CONDITION\", \"PER_CONDITION_AND_TARGET\"]).default(\"PER_POLICY\").describe(\"Determines how incidents are grouped. PER_POLICY: one issue per policy (recommended for most use cases). PER_CONDITION: one issue per alert condition. PER_CONDITION_AND_TARGET: one issue per condition and signal/target.\").optional(),\n});\nconst NewRelicCreateAlertPolicy_LinksSchema = z.object({\n  conditions: z.array(z.number().int()).describe(\"A list of condition IDs associated with the policy.\").nullable().optional(),\n});\nconst NewRelicCreateAlertPolicy_PolicySchema = z.object({\n  id: z.number().int().describe(\"Unique ID of the alert policy.\").nullable(),\n  name: z.string().describe(\"The name of the alert policy.\").nullable(),\n  links: NewRelicCreateAlertPolicy_LinksSchema.nullable().optional(),\n  created_at: z.number().int().describe(\"Timestamp (in milliseconds since epoch) when the alert policy was created.\").nullable(),\n  updated_at: z.number().int().describe(\"Timestamp (in milliseconds since epoch) when the alert policy was last updated.\").nullable(),\n  incident_preference: z.string().describe(\"Incident preference setting. One of: PER_POLICY, PER_CONDITION, or PER_CONDITION_AND_TARGET.\").nullable(),\n});\nexport const NewRelicCreateAlertPolicyOutput = z.object({\n  policy: NewRelicCreateAlertPolicy_PolicySchema.nullable(),\n});\n\nexport const newRelicCreateAlertPolicy = action(\"NEW_RELIC_CREATE_ALERT_POLICY\", {\n  slug: \"new_relic-create-alert-policy\",\n  name: \"Create Alert Policy\",\n  description: \"Creates a new alert policy in New Relic. Alert policies are containers for alert conditions and define how incidents are grouped. Use this to set up monitoring thresholds and notification rules for your applications.\",\n  input: NewRelicCreateAlertPolicyInput,\n  output: NewRelicCreateAlertPolicyOutput,\n});\n"],"mappings":";;;AAIA,MAAa,iCAAiC,EAAE,OAAO;CACrD,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,kEAAkE;CAC5F,qBAAqB,EAAE,KAAK;EAAC;EAAc;EAAiB;CAA0B,CAAC,CAAC,CAAC,QAAQ,YAAY,CAAC,CAAC,SAAS,6NAA6N,CAAC,CAAC,SAAS;AAClW,CAAC;AACD,MAAM,wCAAwC,EAAE,OAAO,EACrD,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,qDAAqD,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,EAC5H,CAAC;AACD,MAAM,yCAAyC,EAAE,OAAO;CACtD,IAAI,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,gCAAgC,CAAC,CAAC,SAAS;CACzE,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,+BAA+B,CAAC,CAAC,SAAS;CACpE,OAAO,sCAAsC,SAAS,CAAC,CAAC,SAAS;CACjE,YAAY,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,4EAA4E,CAAC,CAAC,SAAS;CAC7H,YAAY,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,iFAAiF,CAAC,CAAC,SAAS;CAClI,qBAAqB,EAAE,OAAO,CAAC,CAAC,SAAS,8FAA8F,CAAC,CAAC,SAAS;AACpJ,CAAC;AAKD,MAAa,4BAA4B,OAAO,iCAAiC;CAC/E,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAAO;CACP,QAT6C,EAAE,OAAO,EACtD,QAAQ,uCAAuC,SAAS,EAC1D,CAOU;AACV,CAAC"}

package/dist/actions/create-alerts-nrql-condition-static.cjs

@@ -40,9 +40,9 @@ const NewRelicCreateAlertsNrqlConditionStaticInput = zod.z.object({
 	violationTimeLimitSeconds: zod.z.number().int().describe("Maximum duration in seconds that a violation can remain open. Must be between 300 and 2592000 seconds (30 days).")
 }).describe("Request parameters for creating a static NRQL alert condition.");
 const NewRelicCreateAlertsNrqlConditionStaticOutput = zod.z.object({
-	id: zod.z.string().describe("Unique identifier for the created alert condition."),
-	name: zod.z.string().describe("Name of the created alert condition."),
-	enabled: zod.z.boolean().describe("Whether the alert condition is enabled.")
+	id: zod.z.string().describe("Unique identifier for the created alert condition.").nullable(),
+	name: zod.z.string().describe("Name of the created alert condition.").nullable(),
+	enabled: zod.z.boolean().describe("Whether the alert condition is enabled.").nullable()
 }).describe("Response from creating a static NRQL alert condition.");
 const newRelicCreateAlertsNrqlConditionStatic = require_action.action("NEW_RELIC_CREATE_ALERTS_NRQL_CONDITION_STATIC", {
 	slug: "new_relic-create-alerts-nrql-condition-static",

package/dist/actions/create-alerts-nrql-condition-static.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-alerts-nrql-condition-static.cjs","names":["z","action"],"sources":["../../src/actions/create-alerts-nrql-condition-static.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateAlertsNrqlConditionStaticInput: z.ZodTypeAny = z.object({\n  name: z.string().describe(\"Name of the NRQL alert condition. Must be unique within the policy.\"),\n  nrql: z.object({\n  query: z.string().describe(\"The NRQL query string to evaluate for the alert condition.\"),\n}).describe(\"NRQL query configuration that defines what data to monitor.\"),\n  terms: z.object({\n  operator: z.enum([\"ABOVE\", \"ABOVE_OR_EQUALS\", \"BELOW\", \"BELOW_OR_EQUALS\", \"EQUALS\", \"NOT_EQUALS\"]).describe(\"Comparison operator used to evaluate the query result against the threshold.\"),\n  priority: z.enum([\"CRITICAL\", \"WARNING\"]).describe(\"Priority level for the alert. CRITICAL alerts require immediate attention, WARNING alerts are informational.\"),\n  threshold: z.number().describe(\"The threshold value that triggers the alert when crossed according to the operator.\"),\n  thresholdDuration: z.number().int().describe(\"Duration in seconds that the threshold must be violated before triggering an alert. Must be a multiple of 60 (1-120 minutes).\"),\n  thresholdOccurrences: z.enum([\"ALL\", \"AT_LEAST_ONCE\"]).describe(\"How threshold occurrences are evaluated. ALL: every data point must violate. AT_LEAST_ONCE: at least one data point must violate.\"),\n}).describe(\"Threshold configuration that defines when alerts are triggered.\"),\n  signal: z.object({\n  aggregationDelay: z.number().int().describe(\"Delay in seconds before evaluating the signal to allow for data to arrive. Useful for handling late-arriving data. Must be between 0 and 1200 seconds.\").optional(),\n  aggregationMethod: z.enum([\"EVENT_FLOW\", \"EVENT_TIMER\", \"CADENCE\"]).describe(\"Method used for aggregating data points. EVENT_FLOW is recommended for most use cases.\"),\n  aggregationWindow: z.number().int().describe(\"Duration in seconds of the time window used to aggregate data. Must be between 30 and 120 seconds.\"),\n}).describe(\"Configuration for how data signals are aggregated and evaluated.\"),\n  enabled: z.boolean().default(true).describe(\"Whether the alert condition is enabled and actively monitoring.\").optional(),\n  policy_id: z.string().describe(\"The ID of the alert policy to attach this condition to. The policy must exist in the specified account.\"),\n  account_id: z.number().int().describe(\"The New Relic account ID where the alert condition will be created.\"),\n  expiration: z.object({\n  expirationDuration: z.number().int().describe(\"Duration in seconds after which a signal is considered expired if no data is received. Must be between 30 and 172800 seconds (48 hours).\").optional(),\n  openViolationOnExpiration: z.boolean().describe(\"Whether to open a violation when the signal expires (loss of signal detection).\").optional(),\n  closeViolationsOnExpiration: z.boolean().describe(\"Whether to close existing violations when the signal expires.\").optional(),\n}).describe(\"Configuration for alert expiration and signal loss handling.\").optional(),\n  description: z.string().describe(\"Optional description providing context about the alert condition.\").optional(),\n  valueFunction: z.enum([\"SINGLE_VALUE\", \"SUM\"]).describe(\"Value function applied to the NRQL query result. SINGLE_VALUE for scalar results, SUM for aggregated values.\"),\n  violationTimeLimitSeconds: z.number().int().describe(\"Maximum duration in seconds that a violation can remain open. Must be between 300 and 2592000 seconds (30 days).\"),\n}).describe(\"Request parameters for creating a static NRQL alert condition.\");\nexport const NewRelicCreateAlertsNrqlConditionStaticOutput: z.ZodTypeAny = z.object({\n  id: z.string().describe(\"Unique identifier for the created alert condition.\"),\n  name: z.string().describe(\"Name of the created alert condition.\"),\n  enabled: z.boolean().describe(\"Whether the alert condition is enabled.\"),\n}).describe(\"Response from creating a static NRQL alert condition.\");\n\nexport const newRelicCreateAlertsNrqlConditionStatic = action(\"NEW_RELIC_CREATE_ALERTS_NRQL_CONDITION_STATIC\", {\n  slug: \"new_relic-create-alerts-nrql-condition-static\",\n  name: \"Create Static NRQL Alert Condition\",\n  description: \"Tool to create a static NRQL alert condition using New Relic's NerdGraph GraphQL API. Use when you need to set up monitoring for specific NRQL query results with threshold-based alerting. Supports signal loss detection and gap filling configuration.\",\n  input: NewRelicCreateAlertsNrqlConditionStaticInput,\n  output: NewRelicCreateAlertsNrqlConditionStaticOutput,\n});\n"],"mappings":";;;AAIA,MAAa,+CAA6DA,IAAAA,EAAE,OAAO;CACjF,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,qEAAqE;CAC/F,MAAMA,IAAAA,EAAE,OAAO,EACf,OAAOA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,4DAA4D,EACzF,CAAC,CAAC,CAAC,SAAS,6DAA6D;CACvE,OAAOA,IAAAA,EAAE,OAAO;EAChB,UAAUA,IAAAA,EAAE,KAAK;GAAC;GAAS;GAAmB;GAAS;GAAmB;GAAU;EAAY,CAAC,CAAC,CAAC,SAAS,8EAA8E;EAC1L,UAAUA,IAAAA,EAAE,KAAK,CAAC,YAAY,SAAS,CAAC,CAAC,CAAC,SAAS,8GAA8G;EACjK,WAAWA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,qFAAqF;EACpH,mBAAmBA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,+HAA+H;EAC5K,sBAAsBA,IAAAA,EAAE,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,SAAS,mIAAmI;CACrM,CAAC,CAAC,CAAC,SAAS,iEAAiE;CAC3E,QAAQA,IAAAA,EAAE,OAAO;EACjB,kBAAkBA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,wJAAwJ,CAAC,CAAC,SAAS;EAC/M,mBAAmBA,IAAAA,EAAE,KAAK;GAAC;GAAc;GAAe;EAAS,CAAC,CAAC,CAAC,SAAS,wFAAwF;EACrK,mBAAmBA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,oGAAoG;CACnJ,CAAC,CAAC,CAAC,SAAS,kEAAkE;CAC5E,SAASA,IAAAA,EAAE,QAAQ,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,SAAS,iEAAiE,CAAC,CAAC,SAAS;CACxH,WAAWA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,yGAAyG;CACxI,YAAYA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,qEAAqE;CAC3G,YAAYA,IAAAA,EAAE,OAAO;EACrB,oBAAoBA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,0IAA0I,CAAC,CAAC,SAAS;EACnM,2BAA2BA,IAAAA,EAAE,QAAQ,CAAC,CAAC,SAAS,iFAAiF,CAAC,CAAC,SAAS;EAC5I,6BAA6BA,IAAAA,EAAE,QAAQ,CAAC,CAAC,SAAS,+DAA+D,CAAC,CAAC,SAAS;CAC9H,CAAC,CAAC,CAAC,SAAS,8DAA8D,CAAC,CAAC,SAAS;CACnF,aAAaA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,mEAAmE,CAAC,CAAC,SAAS;CAC/G,eAAeA,IAAAA,EAAE,KAAK,CAAC,gBAAgB,KAAK,CAAC,CAAC,CAAC,SAAS,8GAA8G;CACtK,2BAA2BA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,kHAAkH;AACzK,CAAC,CAAC,CAAC,SAAS,gEAAgE;AAC5E,MAAa,gDAA8DA,IAAAA,EAAE,OAAO;CAClF,IAAIA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,oDAAoD;CAC5E,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,sCAAsC;CAChE,SAASA,IAAAA,EAAE,QAAQ,CAAC,CAAC,SAAS,yCAAyC;AACzE,CAAC,CAAC,CAAC,SAAS,uDAAuD;AAEnE,MAAa,0CAA0CC,eAAAA,OAAO,iDAAiD;CAC7G,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAAO;CACP,QAAQ;AACV,CAAC"}
+{"version":3,"file":"create-alerts-nrql-condition-static.cjs","names":["z","action"],"sources":["../../src/actions/create-alerts-nrql-condition-static.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateAlertsNrqlConditionStaticInput = z.object({\n  name: z.string().describe(\"Name of the NRQL alert condition. Must be unique within the policy.\"),\n  nrql: z.object({\n  query: z.string().describe(\"The NRQL query string to evaluate for the alert condition.\"),\n}).describe(\"NRQL query configuration that defines what data to monitor.\"),\n  terms: z.object({\n  operator: z.enum([\"ABOVE\", \"ABOVE_OR_EQUALS\", \"BELOW\", \"BELOW_OR_EQUALS\", \"EQUALS\", \"NOT_EQUALS\"]).describe(\"Comparison operator used to evaluate the query result against the threshold.\"),\n  priority: z.enum([\"CRITICAL\", \"WARNING\"]).describe(\"Priority level for the alert. CRITICAL alerts require immediate attention, WARNING alerts are informational.\"),\n  threshold: z.number().describe(\"The threshold value that triggers the alert when crossed according to the operator.\"),\n  thresholdDuration: z.number().int().describe(\"Duration in seconds that the threshold must be violated before triggering an alert. Must be a multiple of 60 (1-120 minutes).\"),\n  thresholdOccurrences: z.enum([\"ALL\", \"AT_LEAST_ONCE\"]).describe(\"How threshold occurrences are evaluated. ALL: every data point must violate. AT_LEAST_ONCE: at least one data point must violate.\"),\n}).describe(\"Threshold configuration that defines when alerts are triggered.\"),\n  signal: z.object({\n  aggregationDelay: z.number().int().describe(\"Delay in seconds before evaluating the signal to allow for data to arrive. Useful for handling late-arriving data. Must be between 0 and 1200 seconds.\").optional(),\n  aggregationMethod: z.enum([\"EVENT_FLOW\", \"EVENT_TIMER\", \"CADENCE\"]).describe(\"Method used for aggregating data points. EVENT_FLOW is recommended for most use cases.\"),\n  aggregationWindow: z.number().int().describe(\"Duration in seconds of the time window used to aggregate data. Must be between 30 and 120 seconds.\"),\n}).describe(\"Configuration for how data signals are aggregated and evaluated.\"),\n  enabled: z.boolean().default(true).describe(\"Whether the alert condition is enabled and actively monitoring.\").optional(),\n  policy_id: z.string().describe(\"The ID of the alert policy to attach this condition to. The policy must exist in the specified account.\"),\n  account_id: z.number().int().describe(\"The New Relic account ID where the alert condition will be created.\"),\n  expiration: z.object({\n  expirationDuration: z.number().int().describe(\"Duration in seconds after which a signal is considered expired if no data is received. Must be between 30 and 172800 seconds (48 hours).\").optional(),\n  openViolationOnExpiration: z.boolean().describe(\"Whether to open a violation when the signal expires (loss of signal detection).\").optional(),\n  closeViolationsOnExpiration: z.boolean().describe(\"Whether to close existing violations when the signal expires.\").optional(),\n}).describe(\"Configuration for alert expiration and signal loss handling.\").optional(),\n  description: z.string().describe(\"Optional description providing context about the alert condition.\").optional(),\n  valueFunction: z.enum([\"SINGLE_VALUE\", \"SUM\"]).describe(\"Value function applied to the NRQL query result. SINGLE_VALUE for scalar results, SUM for aggregated values.\"),\n  violationTimeLimitSeconds: z.number().int().describe(\"Maximum duration in seconds that a violation can remain open. Must be between 300 and 2592000 seconds (30 days).\"),\n}).describe(\"Request parameters for creating a static NRQL alert condition.\");\nexport const NewRelicCreateAlertsNrqlConditionStaticOutput = z.object({\n  id: z.string().describe(\"Unique identifier for the created alert condition.\").nullable(),\n  name: z.string().describe(\"Name of the created alert condition.\").nullable(),\n  enabled: z.boolean().describe(\"Whether the alert condition is enabled.\").nullable(),\n}).describe(\"Response from creating a static NRQL alert condition.\");\n\nexport const newRelicCreateAlertsNrqlConditionStatic = action(\"NEW_RELIC_CREATE_ALERTS_NRQL_CONDITION_STATIC\", {\n  slug: \"new_relic-create-alerts-nrql-condition-static\",\n  name: \"Create Static NRQL Alert Condition\",\n  description: \"Tool to create a static NRQL alert condition using New Relic's NerdGraph GraphQL API. Use when you need to set up monitoring for specific NRQL query results with threshold-based alerting. Supports signal loss detection and gap filling configuration.\",\n  input: NewRelicCreateAlertsNrqlConditionStaticInput,\n  output: NewRelicCreateAlertsNrqlConditionStaticOutput,\n});\n"],"mappings":";;;AAIA,MAAa,+CAA+CA,IAAAA,EAAE,OAAO;CACnE,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,qEAAqE;CAC/F,MAAMA,IAAAA,EAAE,OAAO,EACf,OAAOA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,4DAA4D,EACzF,CAAC,CAAC,CAAC,SAAS,6DAA6D;CACvE,OAAOA,IAAAA,EAAE,OAAO;EAChB,UAAUA,IAAAA,EAAE,KAAK;GAAC;GAAS;GAAmB;GAAS;GAAmB;GAAU;EAAY,CAAC,CAAC,CAAC,SAAS,8EAA8E;EAC1L,UAAUA,IAAAA,EAAE,KAAK,CAAC,YAAY,SAAS,CAAC,CAAC,CAAC,SAAS,8GAA8G;EACjK,WAAWA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,qFAAqF;EACpH,mBAAmBA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,+HAA+H;EAC5K,sBAAsBA,IAAAA,EAAE,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,SAAS,mIAAmI;CACrM,CAAC,CAAC,CAAC,SAAS,iEAAiE;CAC3E,QAAQA,IAAAA,EAAE,OAAO;EACjB,kBAAkBA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,wJAAwJ,CAAC,CAAC,SAAS;EAC/M,mBAAmBA,IAAAA,EAAE,KAAK;GAAC;GAAc;GAAe;EAAS,CAAC,CAAC,CAAC,SAAS,wFAAwF;EACrK,mBAAmBA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,oGAAoG;CACnJ,CAAC,CAAC,CAAC,SAAS,kEAAkE;CAC5E,SAASA,IAAAA,EAAE,QAAQ,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,SAAS,iEAAiE,CAAC,CAAC,SAAS;CACxH,WAAWA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,yGAAyG;CACxI,YAAYA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,qEAAqE;CAC3G,YAAYA,IAAAA,EAAE,OAAO;EACrB,oBAAoBA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,0IAA0I,CAAC,CAAC,SAAS;EACnM,2BAA2BA,IAAAA,EAAE,QAAQ,CAAC,CAAC,SAAS,iFAAiF,CAAC,CAAC,SAAS;EAC5I,6BAA6BA,IAAAA,EAAE,QAAQ,CAAC,CAAC,SAAS,+DAA+D,CAAC,CAAC,SAAS;CAC9H,CAAC,CAAC,CAAC,SAAS,8DAA8D,CAAC,CAAC,SAAS;CACnF,aAAaA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,mEAAmE,CAAC,CAAC,SAAS;CAC/G,eAAeA,IAAAA,EAAE,KAAK,CAAC,gBAAgB,KAAK,CAAC,CAAC,CAAC,SAAS,8GAA8G;CACtK,2BAA2BA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,kHAAkH;AACzK,CAAC,CAAC,CAAC,SAAS,gEAAgE;AAC5E,MAAa,gDAAgDA,IAAAA,EAAE,OAAO;CACpE,IAAIA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,oDAAoD,CAAC,CAAC,SAAS;CACvF,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,sCAAsC,CAAC,CAAC,SAAS;CAC3E,SAASA,IAAAA,EAAE,QAAQ,CAAC,CAAC,SAAS,yCAAyC,CAAC,CAAC,SAAS;AACpF,CAAC,CAAC,CAAC,SAAS,uDAAuD;AAEnE,MAAa,0CAA0CC,eAAAA,OAAO,iDAAiD;CAC7G,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAAO;CACP,QAAQ;AACV,CAAC"}

package/dist/actions/create-alerts-nrql-condition-static.d.cts

@@ -1,9 +1,89 @@
 import { z } from "zod";
 
 //#region src/actions/create-alerts-nrql-condition-static.d.ts
-declare const NewRelicCreateAlertsNrqlConditionStaticInput: z.ZodTypeAny;
-declare const NewRelicCreateAlertsNrqlConditionStaticOutput: z.ZodTypeAny;
-declare const newRelicCreateAlertsNrqlConditionStatic: import("@keystrokehq/action").WorkflowActionDefinition<unknown, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
+declare const NewRelicCreateAlertsNrqlConditionStaticInput: z.ZodObject<{
+  name: z.ZodString;
+  nrql: z.ZodObject<{
+    query: z.ZodString;
+  }, z.core.$strip>;
+  terms: z.ZodObject<{
+    operator: z.ZodEnum<{
+      ABOVE: "ABOVE";
+      ABOVE_OR_EQUALS: "ABOVE_OR_EQUALS";
+      BELOW: "BELOW";
+      BELOW_OR_EQUALS: "BELOW_OR_EQUALS";
+      EQUALS: "EQUALS";
+      NOT_EQUALS: "NOT_EQUALS";
+    }>;
+    priority: z.ZodEnum<{
+      CRITICAL: "CRITICAL";
+      WARNING: "WARNING";
+    }>;
+    threshold: z.ZodNumber;
+    thresholdDuration: z.ZodNumber;
+    thresholdOccurrences: z.ZodEnum<{
+      ALL: "ALL";
+      AT_LEAST_ONCE: "AT_LEAST_ONCE";
+    }>;
+  }, z.core.$strip>;
+  signal: z.ZodObject<{
+    aggregationDelay: z.ZodOptional<z.ZodNumber>;
+    aggregationMethod: z.ZodEnum<{
+      EVENT_FLOW: "EVENT_FLOW";
+      EVENT_TIMER: "EVENT_TIMER";
+      CADENCE: "CADENCE";
+    }>;
+    aggregationWindow: z.ZodNumber;
+  }, z.core.$strip>;
+  enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+  policy_id: z.ZodString;
+  account_id: z.ZodNumber;
+  expiration: z.ZodOptional<z.ZodObject<{
+    expirationDuration: z.ZodOptional<z.ZodNumber>;
+    openViolationOnExpiration: z.ZodOptional<z.ZodBoolean>;
+    closeViolationsOnExpiration: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  description: z.ZodOptional<z.ZodString>;
+  valueFunction: z.ZodEnum<{
+    SINGLE_VALUE: "SINGLE_VALUE";
+    SUM: "SUM";
+  }>;
+  violationTimeLimitSeconds: z.ZodNumber;
+}, z.core.$strip>;
+declare const NewRelicCreateAlertsNrqlConditionStaticOutput: z.ZodObject<{
+  id: z.ZodNullable<z.ZodString>;
+  name: z.ZodNullable<z.ZodString>;
+  enabled: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const newRelicCreateAlertsNrqlConditionStatic: import("@keystrokehq/action").WorkflowActionDefinition<{
+  name: string;
+  nrql: {
+    query: string;
+  };
+  terms: {
+    operator: "ABOVE" | "ABOVE_OR_EQUALS" | "BELOW" | "BELOW_OR_EQUALS" | "EQUALS" | "NOT_EQUALS";
+    priority: "CRITICAL" | "WARNING";
+    threshold: number;
+    thresholdDuration: number;
+    thresholdOccurrences: "ALL" | "AT_LEAST_ONCE";
+  };
+  signal: {
+    aggregationMethod: "EVENT_FLOW" | "EVENT_TIMER" | "CADENCE";
+    aggregationWindow: number;
+    aggregationDelay?: number | undefined;
+  };
+  policy_id: string;
+  account_id: number;
+  valueFunction: "SINGLE_VALUE" | "SUM";
+  violationTimeLimitSeconds: number;
+  enabled?: boolean | undefined;
+  expiration?: {
+    expirationDuration?: number | undefined;
+    openViolationOnExpiration?: boolean | undefined;
+    closeViolationsOnExpiration?: boolean | undefined;
+  } | undefined;
+  description?: string | undefined;
+}, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
 //#endregion
 export { newRelicCreateAlertsNrqlConditionStatic };
 //# sourceMappingURL=create-alerts-nrql-condition-static.d.cts.map

package/dist/actions/create-alerts-nrql-condition-static.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"create-alerts-nrql-condition-static.d.cts","names":[],"sources":["../../src/actions/create-alerts-nrql-condition-static.ts"],"mappings":";;;cAIa,4CAAA,EAA8C,CAAA,CAAE,UA4BgB;AAAA,cAChE,6CAAA,EAA+C,CAAA,CAAE,UAIM;AAAA,cAEvD,uCAAA,gCAAuC,wBAAA,iDAAA,mBAAA,yCAAA,UAAA,4CAAA,UAAA"}
+{"version":3,"file":"create-alerts-nrql-condition-static.d.cts","names":[],"sources":["../../src/actions/create-alerts-nrql-condition-static.ts"],"mappings":";;;cAIa,4CAAA,EAA4C,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6B5C,6CAAA,EAA6C,CAAA,CAAA,SAAA;;;;;cAM7C,uCAAA,gCAAuC,wBAAA"}

package/dist/actions/create-alerts-nrql-condition-static.d.mts

@@ -1,9 +1,89 @@
 import { z } from "zod";
 
 //#region src/actions/create-alerts-nrql-condition-static.d.ts
-declare const NewRelicCreateAlertsNrqlConditionStaticInput: z.ZodTypeAny;
-declare const NewRelicCreateAlertsNrqlConditionStaticOutput: z.ZodTypeAny;
-declare const newRelicCreateAlertsNrqlConditionStatic: import("@keystrokehq/action").WorkflowActionDefinition<unknown, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
+declare const NewRelicCreateAlertsNrqlConditionStaticInput: z.ZodObject<{
+  name: z.ZodString;
+  nrql: z.ZodObject<{
+    query: z.ZodString;
+  }, z.core.$strip>;
+  terms: z.ZodObject<{
+    operator: z.ZodEnum<{
+      ABOVE: "ABOVE";
+      ABOVE_OR_EQUALS: "ABOVE_OR_EQUALS";
+      BELOW: "BELOW";
+      BELOW_OR_EQUALS: "BELOW_OR_EQUALS";
+      EQUALS: "EQUALS";
+      NOT_EQUALS: "NOT_EQUALS";
+    }>;
+    priority: z.ZodEnum<{
+      CRITICAL: "CRITICAL";
+      WARNING: "WARNING";
+    }>;
+    threshold: z.ZodNumber;
+    thresholdDuration: z.ZodNumber;
+    thresholdOccurrences: z.ZodEnum<{
+      ALL: "ALL";
+      AT_LEAST_ONCE: "AT_LEAST_ONCE";
+    }>;
+  }, z.core.$strip>;
+  signal: z.ZodObject<{
+    aggregationDelay: z.ZodOptional<z.ZodNumber>;
+    aggregationMethod: z.ZodEnum<{
+      EVENT_FLOW: "EVENT_FLOW";
+      EVENT_TIMER: "EVENT_TIMER";
+      CADENCE: "CADENCE";
+    }>;
+    aggregationWindow: z.ZodNumber;
+  }, z.core.$strip>;
+  enabled: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+  policy_id: z.ZodString;
+  account_id: z.ZodNumber;
+  expiration: z.ZodOptional<z.ZodObject<{
+    expirationDuration: z.ZodOptional<z.ZodNumber>;
+    openViolationOnExpiration: z.ZodOptional<z.ZodBoolean>;
+    closeViolationsOnExpiration: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  description: z.ZodOptional<z.ZodString>;
+  valueFunction: z.ZodEnum<{
+    SINGLE_VALUE: "SINGLE_VALUE";
+    SUM: "SUM";
+  }>;
+  violationTimeLimitSeconds: z.ZodNumber;
+}, z.core.$strip>;
+declare const NewRelicCreateAlertsNrqlConditionStaticOutput: z.ZodObject<{
+  id: z.ZodNullable<z.ZodString>;
+  name: z.ZodNullable<z.ZodString>;
+  enabled: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const newRelicCreateAlertsNrqlConditionStatic: import("@keystrokehq/action").WorkflowActionDefinition<{
+  name: string;
+  nrql: {
+    query: string;
+  };
+  terms: {
+    operator: "ABOVE" | "ABOVE_OR_EQUALS" | "BELOW" | "BELOW_OR_EQUALS" | "EQUALS" | "NOT_EQUALS";
+    priority: "CRITICAL" | "WARNING";
+    threshold: number;
+    thresholdDuration: number;
+    thresholdOccurrences: "ALL" | "AT_LEAST_ONCE";
+  };
+  signal: {
+    aggregationMethod: "EVENT_FLOW" | "EVENT_TIMER" | "CADENCE";
+    aggregationWindow: number;
+    aggregationDelay?: number | undefined;
+  };
+  policy_id: string;
+  account_id: number;
+  valueFunction: "SINGLE_VALUE" | "SUM";
+  violationTimeLimitSeconds: number;
+  enabled?: boolean | undefined;
+  expiration?: {
+    expirationDuration?: number | undefined;
+    openViolationOnExpiration?: boolean | undefined;
+    closeViolationsOnExpiration?: boolean | undefined;
+  } | undefined;
+  description?: string | undefined;
+}, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
 //#endregion
 export { newRelicCreateAlertsNrqlConditionStatic };
 //# sourceMappingURL=create-alerts-nrql-condition-static.d.mts.map

package/dist/actions/create-alerts-nrql-condition-static.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"create-alerts-nrql-condition-static.d.mts","names":[],"sources":["../../src/actions/create-alerts-nrql-condition-static.ts"],"mappings":";;;cAIa,4CAAA,EAA8C,CAAA,CAAE,UA4BgB;AAAA,cAChE,6CAAA,EAA+C,CAAA,CAAE,UAIM;AAAA,cAEvD,uCAAA,gCAAuC,wBAAA,iDAAA,mBAAA,yCAAA,UAAA,4CAAA,UAAA"}
+{"version":3,"file":"create-alerts-nrql-condition-static.d.mts","names":[],"sources":["../../src/actions/create-alerts-nrql-condition-static.ts"],"mappings":";;;cAIa,4CAAA,EAA4C,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6B5C,6CAAA,EAA6C,CAAA,CAAA,SAAA;;;;;cAM7C,uCAAA,gCAAuC,wBAAA"}

package/dist/actions/create-alerts-nrql-condition-static.mjs

@@ -43,9 +43,9 @@ const newRelicCreateAlertsNrqlConditionStatic = action("NEW_RELIC_CREATE_ALERTS_
 		violationTimeLimitSeconds: z.number().int().describe("Maximum duration in seconds that a violation can remain open. Must be between 300 and 2592000 seconds (30 days).")
 	}).describe("Request parameters for creating a static NRQL alert condition."),
 	output: z.object({
-		id: z.string().describe("Unique identifier for the created alert condition."),
-		name: z.string().describe("Name of the created alert condition."),
-		enabled: z.boolean().describe("Whether the alert condition is enabled.")
+		id: z.string().describe("Unique identifier for the created alert condition.").nullable(),
+		name: z.string().describe("Name of the created alert condition.").nullable(),
+		enabled: z.boolean().describe("Whether the alert condition is enabled.").nullable()
 	}).describe("Response from creating a static NRQL alert condition.")
 });
 //#endregion

package/dist/actions/create-alerts-nrql-condition-static.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-alerts-nrql-condition-static.mjs","names":[],"sources":["../../src/actions/create-alerts-nrql-condition-static.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateAlertsNrqlConditionStaticInput: z.ZodTypeAny = z.object({\n  name: z.string().describe(\"Name of the NRQL alert condition. Must be unique within the policy.\"),\n  nrql: z.object({\n  query: z.string().describe(\"The NRQL query string to evaluate for the alert condition.\"),\n}).describe(\"NRQL query configuration that defines what data to monitor.\"),\n  terms: z.object({\n  operator: z.enum([\"ABOVE\", \"ABOVE_OR_EQUALS\", \"BELOW\", \"BELOW_OR_EQUALS\", \"EQUALS\", \"NOT_EQUALS\"]).describe(\"Comparison operator used to evaluate the query result against the threshold.\"),\n  priority: z.enum([\"CRITICAL\", \"WARNING\"]).describe(\"Priority level for the alert. CRITICAL alerts require immediate attention, WARNING alerts are informational.\"),\n  threshold: z.number().describe(\"The threshold value that triggers the alert when crossed according to the operator.\"),\n  thresholdDuration: z.number().int().describe(\"Duration in seconds that the threshold must be violated before triggering an alert. Must be a multiple of 60 (1-120 minutes).\"),\n  thresholdOccurrences: z.enum([\"ALL\", \"AT_LEAST_ONCE\"]).describe(\"How threshold occurrences are evaluated. ALL: every data point must violate. AT_LEAST_ONCE: at least one data point must violate.\"),\n}).describe(\"Threshold configuration that defines when alerts are triggered.\"),\n  signal: z.object({\n  aggregationDelay: z.number().int().describe(\"Delay in seconds before evaluating the signal to allow for data to arrive. Useful for handling late-arriving data. Must be between 0 and 1200 seconds.\").optional(),\n  aggregationMethod: z.enum([\"EVENT_FLOW\", \"EVENT_TIMER\", \"CADENCE\"]).describe(\"Method used for aggregating data points. EVENT_FLOW is recommended for most use cases.\"),\n  aggregationWindow: z.number().int().describe(\"Duration in seconds of the time window used to aggregate data. Must be between 30 and 120 seconds.\"),\n}).describe(\"Configuration for how data signals are aggregated and evaluated.\"),\n  enabled: z.boolean().default(true).describe(\"Whether the alert condition is enabled and actively monitoring.\").optional(),\n  policy_id: z.string().describe(\"The ID of the alert policy to attach this condition to. The policy must exist in the specified account.\"),\n  account_id: z.number().int().describe(\"The New Relic account ID where the alert condition will be created.\"),\n  expiration: z.object({\n  expirationDuration: z.number().int().describe(\"Duration in seconds after which a signal is considered expired if no data is received. Must be between 30 and 172800 seconds (48 hours).\").optional(),\n  openViolationOnExpiration: z.boolean().describe(\"Whether to open a violation when the signal expires (loss of signal detection).\").optional(),\n  closeViolationsOnExpiration: z.boolean().describe(\"Whether to close existing violations when the signal expires.\").optional(),\n}).describe(\"Configuration for alert expiration and signal loss handling.\").optional(),\n  description: z.string().describe(\"Optional description providing context about the alert condition.\").optional(),\n  valueFunction: z.enum([\"SINGLE_VALUE\", \"SUM\"]).describe(\"Value function applied to the NRQL query result. SINGLE_VALUE for scalar results, SUM for aggregated values.\"),\n  violationTimeLimitSeconds: z.number().int().describe(\"Maximum duration in seconds that a violation can remain open. Must be between 300 and 2592000 seconds (30 days).\"),\n}).describe(\"Request parameters for creating a static NRQL alert condition.\");\nexport const NewRelicCreateAlertsNrqlConditionStaticOutput: z.ZodTypeAny = z.object({\n  id: z.string().describe(\"Unique identifier for the created alert condition.\"),\n  name: z.string().describe(\"Name of the created alert condition.\"),\n  enabled: z.boolean().describe(\"Whether the alert condition is enabled.\"),\n}).describe(\"Response from creating a static NRQL alert condition.\");\n\nexport const newRelicCreateAlertsNrqlConditionStatic = action(\"NEW_RELIC_CREATE_ALERTS_NRQL_CONDITION_STATIC\", {\n  slug: \"new_relic-create-alerts-nrql-condition-static\",\n  name: \"Create Static NRQL Alert Condition\",\n  description: \"Tool to create a static NRQL alert condition using New Relic's NerdGraph GraphQL API. Use when you need to set up monitoring for specific NRQL query results with threshold-based alerting. Supports signal loss detection and gap filling configuration.\",\n  input: NewRelicCreateAlertsNrqlConditionStaticInput,\n  output: NewRelicCreateAlertsNrqlConditionStaticOutput,\n});\n"],"mappings":";;AAuCA,MAAa,0CAA0C,OAAO,iDAAiD;CAC7G,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAvCwE,EAAE,OAAO;EACjF,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,qEAAqE;EAC/F,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,OAAO,CAAC,CAAC,SAAS,4DAA4D,EACzF,CAAC,CAAC,CAAC,SAAS,6DAA6D;EACvE,OAAO,EAAE,OAAO;GAChB,UAAU,EAAE,KAAK;IAAC;IAAS;IAAmB;IAAS;IAAmB;IAAU;GAAY,CAAC,CAAC,CAAC,SAAS,8EAA8E;GAC1L,UAAU,EAAE,KAAK,CAAC,YAAY,SAAS,CAAC,CAAC,CAAC,SAAS,8GAA8G;GACjK,WAAW,EAAE,OAAO,CAAC,CAAC,SAAS,qFAAqF;GACpH,mBAAmB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,+HAA+H;GAC5K,sBAAsB,EAAE,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,SAAS,mIAAmI;EACrM,CAAC,CAAC,CAAC,SAAS,iEAAiE;EAC3E,QAAQ,EAAE,OAAO;GACjB,kBAAkB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,wJAAwJ,CAAC,CAAC,SAAS;GAC/M,mBAAmB,EAAE,KAAK;IAAC;IAAc;IAAe;GAAS,CAAC,CAAC,CAAC,SAAS,wFAAwF;GACrK,mBAAmB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,oGAAoG;EACnJ,CAAC,CAAC,CAAC,SAAS,kEAAkE;EAC5E,SAAS,EAAE,QAAQ,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,SAAS,iEAAiE,CAAC,CAAC,SAAS;EACxH,WAAW,EAAE,OAAO,CAAC,CAAC,SAAS,yGAAyG;EACxI,YAAY,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,qEAAqE;EAC3G,YAAY,EAAE,OAAO;GACrB,oBAAoB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,0IAA0I,CAAC,CAAC,SAAS;GACnM,2BAA2B,EAAE,QAAQ,CAAC,CAAC,SAAS,iFAAiF,CAAC,CAAC,SAAS;GAC5I,6BAA6B,EAAE,QAAQ,CAAC,CAAC,SAAS,+DAA+D,CAAC,CAAC,SAAS;EAC9H,CAAC,CAAC,CAAC,SAAS,8DAA8D,CAAC,CAAC,SAAS;EACnF,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS,mEAAmE,CAAC,CAAC,SAAS;EAC/G,eAAe,EAAE,KAAK,CAAC,gBAAgB,KAAK,CAAC,CAAC,CAAC,SAAS,8GAA8G;EACtK,2BAA2B,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,kHAAkH;CACzK,CAAC,CAAC,CAAC,SAAS,gEAWH;CACP,QAXyE,EAAE,OAAO;EAClF,IAAI,EAAE,OAAO,CAAC,CAAC,SAAS,oDAAoD;EAC5E,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,sCAAsC;EAChE,SAAS,EAAE,QAAQ,CAAC,CAAC,SAAS,yCAAyC;CACzE,CAAC,CAAC,CAAC,SAAS,uDAOF;AACV,CAAC"}
+{"version":3,"file":"create-alerts-nrql-condition-static.mjs","names":[],"sources":["../../src/actions/create-alerts-nrql-condition-static.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateAlertsNrqlConditionStaticInput = z.object({\n  name: z.string().describe(\"Name of the NRQL alert condition. Must be unique within the policy.\"),\n  nrql: z.object({\n  query: z.string().describe(\"The NRQL query string to evaluate for the alert condition.\"),\n}).describe(\"NRQL query configuration that defines what data to monitor.\"),\n  terms: z.object({\n  operator: z.enum([\"ABOVE\", \"ABOVE_OR_EQUALS\", \"BELOW\", \"BELOW_OR_EQUALS\", \"EQUALS\", \"NOT_EQUALS\"]).describe(\"Comparison operator used to evaluate the query result against the threshold.\"),\n  priority: z.enum([\"CRITICAL\", \"WARNING\"]).describe(\"Priority level for the alert. CRITICAL alerts require immediate attention, WARNING alerts are informational.\"),\n  threshold: z.number().describe(\"The threshold value that triggers the alert when crossed according to the operator.\"),\n  thresholdDuration: z.number().int().describe(\"Duration in seconds that the threshold must be violated before triggering an alert. Must be a multiple of 60 (1-120 minutes).\"),\n  thresholdOccurrences: z.enum([\"ALL\", \"AT_LEAST_ONCE\"]).describe(\"How threshold occurrences are evaluated. ALL: every data point must violate. AT_LEAST_ONCE: at least one data point must violate.\"),\n}).describe(\"Threshold configuration that defines when alerts are triggered.\"),\n  signal: z.object({\n  aggregationDelay: z.number().int().describe(\"Delay in seconds before evaluating the signal to allow for data to arrive. Useful for handling late-arriving data. Must be between 0 and 1200 seconds.\").optional(),\n  aggregationMethod: z.enum([\"EVENT_FLOW\", \"EVENT_TIMER\", \"CADENCE\"]).describe(\"Method used for aggregating data points. EVENT_FLOW is recommended for most use cases.\"),\n  aggregationWindow: z.number().int().describe(\"Duration in seconds of the time window used to aggregate data. Must be between 30 and 120 seconds.\"),\n}).describe(\"Configuration for how data signals are aggregated and evaluated.\"),\n  enabled: z.boolean().default(true).describe(\"Whether the alert condition is enabled and actively monitoring.\").optional(),\n  policy_id: z.string().describe(\"The ID of the alert policy to attach this condition to. The policy must exist in the specified account.\"),\n  account_id: z.number().int().describe(\"The New Relic account ID where the alert condition will be created.\"),\n  expiration: z.object({\n  expirationDuration: z.number().int().describe(\"Duration in seconds after which a signal is considered expired if no data is received. Must be between 30 and 172800 seconds (48 hours).\").optional(),\n  openViolationOnExpiration: z.boolean().describe(\"Whether to open a violation when the signal expires (loss of signal detection).\").optional(),\n  closeViolationsOnExpiration: z.boolean().describe(\"Whether to close existing violations when the signal expires.\").optional(),\n}).describe(\"Configuration for alert expiration and signal loss handling.\").optional(),\n  description: z.string().describe(\"Optional description providing context about the alert condition.\").optional(),\n  valueFunction: z.enum([\"SINGLE_VALUE\", \"SUM\"]).describe(\"Value function applied to the NRQL query result. SINGLE_VALUE for scalar results, SUM for aggregated values.\"),\n  violationTimeLimitSeconds: z.number().int().describe(\"Maximum duration in seconds that a violation can remain open. Must be between 300 and 2592000 seconds (30 days).\"),\n}).describe(\"Request parameters for creating a static NRQL alert condition.\");\nexport const NewRelicCreateAlertsNrqlConditionStaticOutput = z.object({\n  id: z.string().describe(\"Unique identifier for the created alert condition.\").nullable(),\n  name: z.string().describe(\"Name of the created alert condition.\").nullable(),\n  enabled: z.boolean().describe(\"Whether the alert condition is enabled.\").nullable(),\n}).describe(\"Response from creating a static NRQL alert condition.\");\n\nexport const newRelicCreateAlertsNrqlConditionStatic = action(\"NEW_RELIC_CREATE_ALERTS_NRQL_CONDITION_STATIC\", {\n  slug: \"new_relic-create-alerts-nrql-condition-static\",\n  name: \"Create Static NRQL Alert Condition\",\n  description: \"Tool to create a static NRQL alert condition using New Relic's NerdGraph GraphQL API. Use when you need to set up monitoring for specific NRQL query results with threshold-based alerting. Supports signal loss detection and gap filling configuration.\",\n  input: NewRelicCreateAlertsNrqlConditionStaticInput,\n  output: NewRelicCreateAlertsNrqlConditionStaticOutput,\n});\n"],"mappings":";;AAuCA,MAAa,0CAA0C,OAAO,iDAAiD;CAC7G,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAvC0D,EAAE,OAAO;EACnE,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,qEAAqE;EAC/F,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,OAAO,CAAC,CAAC,SAAS,4DAA4D,EACzF,CAAC,CAAC,CAAC,SAAS,6DAA6D;EACvE,OAAO,EAAE,OAAO;GAChB,UAAU,EAAE,KAAK;IAAC;IAAS;IAAmB;IAAS;IAAmB;IAAU;GAAY,CAAC,CAAC,CAAC,SAAS,8EAA8E;GAC1L,UAAU,EAAE,KAAK,CAAC,YAAY,SAAS,CAAC,CAAC,CAAC,SAAS,8GAA8G;GACjK,WAAW,EAAE,OAAO,CAAC,CAAC,SAAS,qFAAqF;GACpH,mBAAmB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,+HAA+H;GAC5K,sBAAsB,EAAE,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,SAAS,mIAAmI;EACrM,CAAC,CAAC,CAAC,SAAS,iEAAiE;EAC3E,QAAQ,EAAE,OAAO;GACjB,kBAAkB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,wJAAwJ,CAAC,CAAC,SAAS;GAC/M,mBAAmB,EAAE,KAAK;IAAC;IAAc;IAAe;GAAS,CAAC,CAAC,CAAC,SAAS,wFAAwF;GACrK,mBAAmB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,oGAAoG;EACnJ,CAAC,CAAC,CAAC,SAAS,kEAAkE;EAC5E,SAAS,EAAE,QAAQ,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,SAAS,iEAAiE,CAAC,CAAC,SAAS;EACxH,WAAW,EAAE,OAAO,CAAC,CAAC,SAAS,yGAAyG;EACxI,YAAY,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,qEAAqE;EAC3G,YAAY,EAAE,OAAO;GACrB,oBAAoB,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,0IAA0I,CAAC,CAAC,SAAS;GACnM,2BAA2B,EAAE,QAAQ,CAAC,CAAC,SAAS,iFAAiF,CAAC,CAAC,SAAS;GAC5I,6BAA6B,EAAE,QAAQ,CAAC,CAAC,SAAS,+DAA+D,CAAC,CAAC,SAAS;EAC9H,CAAC,CAAC,CAAC,SAAS,8DAA8D,CAAC,CAAC,SAAS;EACnF,aAAa,EAAE,OAAO,CAAC,CAAC,SAAS,mEAAmE,CAAC,CAAC,SAAS;EAC/G,eAAe,EAAE,KAAK,CAAC,gBAAgB,KAAK,CAAC,CAAC,CAAC,SAAS,8GAA8G;EACtK,2BAA2B,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,kHAAkH;CACzK,CAAC,CAAC,CAAC,SAAS,gEAWH;CACP,QAX2D,EAAE,OAAO;EACpE,IAAI,EAAE,OAAO,CAAC,CAAC,SAAS,oDAAoD,CAAC,CAAC,SAAS;EACvF,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,sCAAsC,CAAC,CAAC,SAAS;EAC3E,SAAS,EAAE,QAAQ,CAAC,CAAC,SAAS,yCAAyC,CAAC,CAAC,SAAS;CACpF,CAAC,CAAC,CAAC,SAAS,uDAOF;AACV,CAAC"}

package/dist/actions/create-alerts-policy-graphql.cjs

@@ -11,9 +11,9 @@ const NewRelicCreateAlertsPolicyGraphqlInput = zod.z.object({
 	]).default("PER_POLICY").describe("Determines how incidents are grouped. PER_POLICY: one issue per policy (recommended for most use cases). PER_CONDITION: one issue per alert condition. PER_CONDITION_AND_TARGET: one issue per condition and signal/target.").optional()
 }).describe("Request parameters for creating an alert policy using NerdGraph GraphQL API.");
 const NewRelicCreateAlertsPolicyGraphqlOutput = zod.z.object({
-	id: zod.z.string().describe("Unique identifier for the created alert policy."),
-	name: zod.z.string().describe("Name of the created alert policy."),
-	incident_preference: zod.z.string().describe("Incident preference setting for the policy.")
+	id: zod.z.string().describe("Unique identifier for the created alert policy.").nullable(),
+	name: zod.z.string().describe("Name of the created alert policy.").nullable(),
+	incident_preference: zod.z.string().describe("Incident preference setting for the policy.").nullable()
 }).describe("Response from creating an alert policy via NerdGraph GraphQL API.");
 const newRelicCreateAlertsPolicyGraphql = require_action.action("NEW_RELIC_CREATE_ALERTS_POLICY_GRAPHQL", {
 	slug: "new_relic-create-alerts-policy-graphql",

package/dist/actions/create-alerts-policy-graphql.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-alerts-policy-graphql.cjs","names":["z","action"],"sources":["../../src/actions/create-alerts-policy-graphql.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateAlertsPolicyGraphqlInput: z.ZodTypeAny = z.object({\n  name: z.string().describe(\"The name of the alert policy. Must be unique within the account.\"),\n  account_id: z.number().int().describe(\"The New Relic account ID where the alert policy will be created.\"),\n  incident_preference: z.enum([\"PER_POLICY\", \"PER_CONDITION\", \"PER_CONDITION_AND_TARGET\"]).default(\"PER_POLICY\").describe(\"Determines how incidents are grouped. PER_POLICY: one issue per policy (recommended for most use cases). PER_CONDITION: one issue per alert condition. PER_CONDITION_AND_TARGET: one issue per condition and signal/target.\").optional(),\n}).describe(\"Request parameters for creating an alert policy using NerdGraph GraphQL API.\");\nexport const NewRelicCreateAlertsPolicyGraphqlOutput: z.ZodTypeAny = z.object({\n  id: z.string().describe(\"Unique identifier for the created alert policy.\"),\n  name: z.string().describe(\"Name of the created alert policy.\"),\n  incident_preference: z.string().describe(\"Incident preference setting for the policy.\"),\n}).describe(\"Response from creating an alert policy via NerdGraph GraphQL API.\");\n\nexport const newRelicCreateAlertsPolicyGraphql = action(\"NEW_RELIC_CREATE_ALERTS_POLICY_GRAPHQL\", {\n  slug: \"new_relic-create-alerts-policy-graphql\",\n  name: \"Create Alert Policy (GraphQL)\",\n  description: \"Tool to create a new alert policy using New Relic's NerdGraph GraphQL API. Use when you need to create a container for grouping alert conditions. Alert policies define how incidents are grouped and managed.\",\n  input: NewRelicCreateAlertsPolicyGraphqlInput,\n  output: NewRelicCreateAlertsPolicyGraphqlOutput,\n});\n"],"mappings":";;;AAIA,MAAa,yCAAuDA,IAAAA,EAAE,OAAO;CAC3E,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,kEAAkE;CAC5F,YAAYA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,kEAAkE;CACxG,qBAAqBA,IAAAA,EAAE,KAAK;EAAC;EAAc;EAAiB;CAA0B,CAAC,CAAC,CAAC,QAAQ,YAAY,CAAC,CAAC,SAAS,6NAA6N,CAAC,CAAC,SAAS;AAClW,CAAC,CAAC,CAAC,SAAS,8EAA8E;AAC1F,MAAa,0CAAwDA,IAAAA,EAAE,OAAO;CAC5E,IAAIA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,iDAAiD;CACzE,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,mCAAmC;CAC7D,qBAAqBA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,6CAA6C;AACxF,CAAC,CAAC,CAAC,SAAS,mEAAmE;AAE/E,MAAa,oCAAoCC,eAAAA,OAAO,0CAA0C;CAChG,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAAO;CACP,QAAQ;AACV,CAAC"}
+{"version":3,"file":"create-alerts-policy-graphql.cjs","names":["z","action"],"sources":["../../src/actions/create-alerts-policy-graphql.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateAlertsPolicyGraphqlInput = z.object({\n  name: z.string().describe(\"The name of the alert policy. Must be unique within the account.\"),\n  account_id: z.number().int().describe(\"The New Relic account ID where the alert policy will be created.\"),\n  incident_preference: z.enum([\"PER_POLICY\", \"PER_CONDITION\", \"PER_CONDITION_AND_TARGET\"]).default(\"PER_POLICY\").describe(\"Determines how incidents are grouped. PER_POLICY: one issue per policy (recommended for most use cases). PER_CONDITION: one issue per alert condition. PER_CONDITION_AND_TARGET: one issue per condition and signal/target.\").optional(),\n}).describe(\"Request parameters for creating an alert policy using NerdGraph GraphQL API.\");\nexport const NewRelicCreateAlertsPolicyGraphqlOutput = z.object({\n  id: z.string().describe(\"Unique identifier for the created alert policy.\").nullable(),\n  name: z.string().describe(\"Name of the created alert policy.\").nullable(),\n  incident_preference: z.string().describe(\"Incident preference setting for the policy.\").nullable(),\n}).describe(\"Response from creating an alert policy via NerdGraph GraphQL API.\");\n\nexport const newRelicCreateAlertsPolicyGraphql = action(\"NEW_RELIC_CREATE_ALERTS_POLICY_GRAPHQL\", {\n  slug: \"new_relic-create-alerts-policy-graphql\",\n  name: \"Create Alert Policy (GraphQL)\",\n  description: \"Tool to create a new alert policy using New Relic's NerdGraph GraphQL API. Use when you need to create a container for grouping alert conditions. Alert policies define how incidents are grouped and managed.\",\n  input: NewRelicCreateAlertsPolicyGraphqlInput,\n  output: NewRelicCreateAlertsPolicyGraphqlOutput,\n});\n"],"mappings":";;;AAIA,MAAa,yCAAyCA,IAAAA,EAAE,OAAO;CAC7D,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,kEAAkE;CAC5F,YAAYA,IAAAA,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,kEAAkE;CACxG,qBAAqBA,IAAAA,EAAE,KAAK;EAAC;EAAc;EAAiB;CAA0B,CAAC,CAAC,CAAC,QAAQ,YAAY,CAAC,CAAC,SAAS,6NAA6N,CAAC,CAAC,SAAS;AAClW,CAAC,CAAC,CAAC,SAAS,8EAA8E;AAC1F,MAAa,0CAA0CA,IAAAA,EAAE,OAAO;CAC9D,IAAIA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,iDAAiD,CAAC,CAAC,SAAS;CACpF,MAAMA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,mCAAmC,CAAC,CAAC,SAAS;CACxE,qBAAqBA,IAAAA,EAAE,OAAO,CAAC,CAAC,SAAS,6CAA6C,CAAC,CAAC,SAAS;AACnG,CAAC,CAAC,CAAC,SAAS,mEAAmE;AAE/E,MAAa,oCAAoCC,eAAAA,OAAO,0CAA0C;CAChG,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAAO;CACP,QAAQ;AACV,CAAC"}

package/dist/actions/create-alerts-policy-graphql.d.cts

@@ -1,9 +1,25 @@
 import { z } from "zod";
 
 //#region src/actions/create-alerts-policy-graphql.d.ts
-declare const NewRelicCreateAlertsPolicyGraphqlInput: z.ZodTypeAny;
-declare const NewRelicCreateAlertsPolicyGraphqlOutput: z.ZodTypeAny;
-declare const newRelicCreateAlertsPolicyGraphql: import("@keystrokehq/action").WorkflowActionDefinition<unknown, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
+declare const NewRelicCreateAlertsPolicyGraphqlInput: z.ZodObject<{
+  name: z.ZodString;
+  account_id: z.ZodNumber;
+  incident_preference: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+    PER_POLICY: "PER_POLICY";
+    PER_CONDITION: "PER_CONDITION";
+    PER_CONDITION_AND_TARGET: "PER_CONDITION_AND_TARGET";
+  }>>>;
+}, z.core.$strip>;
+declare const NewRelicCreateAlertsPolicyGraphqlOutput: z.ZodObject<{
+  id: z.ZodNullable<z.ZodString>;
+  name: z.ZodNullable<z.ZodString>;
+  incident_preference: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const newRelicCreateAlertsPolicyGraphql: import("@keystrokehq/action").WorkflowActionDefinition<{
+  name: string;
+  account_id: number;
+  incident_preference?: "PER_POLICY" | "PER_CONDITION" | "PER_CONDITION_AND_TARGET" | undefined;
+}, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
 //#endregion
 export { newRelicCreateAlertsPolicyGraphql };
 //# sourceMappingURL=create-alerts-policy-graphql.d.cts.map

package/dist/actions/create-alerts-policy-graphql.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"create-alerts-policy-graphql.d.cts","names":[],"sources":["../../src/actions/create-alerts-policy-graphql.ts"],"mappings":";;;cAIa,sCAAA,EAAwC,CAAA,CAAE,UAIoC;AAAA,cAC9E,uCAAA,EAAyC,CAAA,CAAE,UAIwB;AAAA,cAEnE,iCAAA,gCAAiC,wBAAA,iDAAA,mBAAA,yCAAA,UAAA,4CAAA,UAAA"}
+{"version":3,"file":"create-alerts-policy-graphql.d.cts","names":[],"sources":["../../src/actions/create-alerts-policy-graphql.ts"],"mappings":";;;cAIa,sCAAA,EAAsC,CAAA,CAAA,SAAA;;;;;;;;;cAKtC,uCAAA,EAAuC,CAAA,CAAA,SAAA;;;;;cAMvC,iCAAA,gCAAiC,wBAAA"}

package/dist/actions/create-alerts-policy-graphql.d.mts

@@ -1,9 +1,25 @@
 import { z } from "zod";
 
 //#region src/actions/create-alerts-policy-graphql.d.ts
-declare const NewRelicCreateAlertsPolicyGraphqlInput: z.ZodTypeAny;
-declare const NewRelicCreateAlertsPolicyGraphqlOutput: z.ZodTypeAny;
-declare const newRelicCreateAlertsPolicyGraphql: import("@keystrokehq/action").WorkflowActionDefinition<unknown, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
+declare const NewRelicCreateAlertsPolicyGraphqlInput: z.ZodObject<{
+  name: z.ZodString;
+  account_id: z.ZodNumber;
+  incident_preference: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+    PER_POLICY: "PER_POLICY";
+    PER_CONDITION: "PER_CONDITION";
+    PER_CONDITION_AND_TARGET: "PER_CONDITION_AND_TARGET";
+  }>>>;
+}, z.core.$strip>;
+declare const NewRelicCreateAlertsPolicyGraphqlOutput: z.ZodObject<{
+  id: z.ZodNullable<z.ZodString>;
+  name: z.ZodNullable<z.ZodString>;
+  incident_preference: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const newRelicCreateAlertsPolicyGraphql: import("@keystrokehq/action").WorkflowActionDefinition<{
+  name: string;
+  account_id: number;
+  incident_preference?: "PER_POLICY" | "PER_CONDITION" | "PER_CONDITION_AND_TARGET" | undefined;
+}, unknown, import("@keystrokehq/shared").ResolvedCredentials<readonly [import("@keystrokehq/shared").Credential]>, readonly [import("@keystrokehq/shared").Credential]>;
 //#endregion
 export { newRelicCreateAlertsPolicyGraphql };
 //# sourceMappingURL=create-alerts-policy-graphql.d.mts.map

package/dist/actions/create-alerts-policy-graphql.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"create-alerts-policy-graphql.d.mts","names":[],"sources":["../../src/actions/create-alerts-policy-graphql.ts"],"mappings":";;;cAIa,sCAAA,EAAwC,CAAA,CAAE,UAIoC;AAAA,cAC9E,uCAAA,EAAyC,CAAA,CAAE,UAIwB;AAAA,cAEnE,iCAAA,gCAAiC,wBAAA,iDAAA,mBAAA,yCAAA,UAAA,4CAAA,UAAA"}
+{"version":3,"file":"create-alerts-policy-graphql.d.mts","names":[],"sources":["../../src/actions/create-alerts-policy-graphql.ts"],"mappings":";;;cAIa,sCAAA,EAAsC,CAAA,CAAA,SAAA;;;;;;;;;cAKtC,uCAAA,EAAuC,CAAA,CAAA,SAAA;;;;;cAMvC,iCAAA,gCAAiC,wBAAA"}

package/dist/actions/create-alerts-policy-graphql.mjs

@@ -14,9 +14,9 @@ const newRelicCreateAlertsPolicyGraphql = action("NEW_RELIC_CREATE_ALERTS_POLICY
 		]).default("PER_POLICY").describe("Determines how incidents are grouped. PER_POLICY: one issue per policy (recommended for most use cases). PER_CONDITION: one issue per alert condition. PER_CONDITION_AND_TARGET: one issue per condition and signal/target.").optional()
 	}).describe("Request parameters for creating an alert policy using NerdGraph GraphQL API."),
 	output: z.object({
-		id: z.string().describe("Unique identifier for the created alert policy."),
-		name: z.string().describe("Name of the created alert policy."),
-		incident_preference: z.string().describe("Incident preference setting for the policy.")
+		id: z.string().describe("Unique identifier for the created alert policy.").nullable(),
+		name: z.string().describe("Name of the created alert policy.").nullable(),
+		incident_preference: z.string().describe("Incident preference setting for the policy.").nullable()
 	}).describe("Response from creating an alert policy via NerdGraph GraphQL API.")
 });
 //#endregion

package/dist/actions/create-alerts-policy-graphql.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"create-alerts-policy-graphql.mjs","names":[],"sources":["../../src/actions/create-alerts-policy-graphql.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateAlertsPolicyGraphqlInput: z.ZodTypeAny = z.object({\n  name: z.string().describe(\"The name of the alert policy. Must be unique within the account.\"),\n  account_id: z.number().int().describe(\"The New Relic account ID where the alert policy will be created.\"),\n  incident_preference: z.enum([\"PER_POLICY\", \"PER_CONDITION\", \"PER_CONDITION_AND_TARGET\"]).default(\"PER_POLICY\").describe(\"Determines how incidents are grouped. PER_POLICY: one issue per policy (recommended for most use cases). PER_CONDITION: one issue per alert condition. PER_CONDITION_AND_TARGET: one issue per condition and signal/target.\").optional(),\n}).describe(\"Request parameters for creating an alert policy using NerdGraph GraphQL API.\");\nexport const NewRelicCreateAlertsPolicyGraphqlOutput: z.ZodTypeAny = z.object({\n  id: z.string().describe(\"Unique identifier for the created alert policy.\"),\n  name: z.string().describe(\"Name of the created alert policy.\"),\n  incident_preference: z.string().describe(\"Incident preference setting for the policy.\"),\n}).describe(\"Response from creating an alert policy via NerdGraph GraphQL API.\");\n\nexport const newRelicCreateAlertsPolicyGraphql = action(\"NEW_RELIC_CREATE_ALERTS_POLICY_GRAPHQL\", {\n  slug: \"new_relic-create-alerts-policy-graphql\",\n  name: \"Create Alert Policy (GraphQL)\",\n  description: \"Tool to create a new alert policy using New Relic's NerdGraph GraphQL API. Use when you need to create a container for grouping alert conditions. Alert policies define how incidents are grouped and managed.\",\n  input: NewRelicCreateAlertsPolicyGraphqlInput,\n  output: NewRelicCreateAlertsPolicyGraphqlOutput,\n});\n"],"mappings":";;AAeA,MAAa,oCAAoC,OAAO,0CAA0C;CAChG,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAfkE,EAAE,OAAO;EAC3E,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,kEAAkE;EAC5F,YAAY,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,kEAAkE;EACxG,qBAAqB,EAAE,KAAK;GAAC;GAAc;GAAiB;EAA0B,CAAC,CAAC,CAAC,QAAQ,YAAY,CAAC,CAAC,SAAS,6NAA6N,CAAC,CAAC,SAAS;CAClW,CAAC,CAAC,CAAC,SAAS,8EAWH;CACP,QAXmE,EAAE,OAAO;EAC5E,IAAI,EAAE,OAAO,CAAC,CAAC,SAAS,iDAAiD;EACzE,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,mCAAmC;EAC7D,qBAAqB,EAAE,OAAO,CAAC,CAAC,SAAS,6CAA6C;CACxF,CAAC,CAAC,CAAC,SAAS,mEAOF;AACV,CAAC"}
+{"version":3,"file":"create-alerts-policy-graphql.mjs","names":[],"sources":["../../src/actions/create-alerts-policy-graphql.ts"],"sourcesContent":["import { z } from \"zod\";\n\nimport { action } from \"../action\";\n\nexport const NewRelicCreateAlertsPolicyGraphqlInput = z.object({\n  name: z.string().describe(\"The name of the alert policy. Must be unique within the account.\"),\n  account_id: z.number().int().describe(\"The New Relic account ID where the alert policy will be created.\"),\n  incident_preference: z.enum([\"PER_POLICY\", \"PER_CONDITION\", \"PER_CONDITION_AND_TARGET\"]).default(\"PER_POLICY\").describe(\"Determines how incidents are grouped. PER_POLICY: one issue per policy (recommended for most use cases). PER_CONDITION: one issue per alert condition. PER_CONDITION_AND_TARGET: one issue per condition and signal/target.\").optional(),\n}).describe(\"Request parameters for creating an alert policy using NerdGraph GraphQL API.\");\nexport const NewRelicCreateAlertsPolicyGraphqlOutput = z.object({\n  id: z.string().describe(\"Unique identifier for the created alert policy.\").nullable(),\n  name: z.string().describe(\"Name of the created alert policy.\").nullable(),\n  incident_preference: z.string().describe(\"Incident preference setting for the policy.\").nullable(),\n}).describe(\"Response from creating an alert policy via NerdGraph GraphQL API.\");\n\nexport const newRelicCreateAlertsPolicyGraphql = action(\"NEW_RELIC_CREATE_ALERTS_POLICY_GRAPHQL\", {\n  slug: \"new_relic-create-alerts-policy-graphql\",\n  name: \"Create Alert Policy (GraphQL)\",\n  description: \"Tool to create a new alert policy using New Relic's NerdGraph GraphQL API. Use when you need to create a container for grouping alert conditions. Alert policies define how incidents are grouped and managed.\",\n  input: NewRelicCreateAlertsPolicyGraphqlInput,\n  output: NewRelicCreateAlertsPolicyGraphqlOutput,\n});\n"],"mappings":";;AAeA,MAAa,oCAAoC,OAAO,0CAA0C;CAChG,MAAM;CACN,MAAM;CACN,aAAa;CACb,OAfoD,EAAE,OAAO;EAC7D,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,kEAAkE;EAC5F,YAAY,EAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,kEAAkE;EACxG,qBAAqB,EAAE,KAAK;GAAC;GAAc;GAAiB;EAA0B,CAAC,CAAC,CAAC,QAAQ,YAAY,CAAC,CAAC,SAAS,6NAA6N,CAAC,CAAC,SAAS;CAClW,CAAC,CAAC,CAAC,SAAS,8EAWH;CACP,QAXqD,EAAE,OAAO;EAC9D,IAAI,EAAE,OAAO,CAAC,CAAC,SAAS,iDAAiD,CAAC,CAAC,SAAS;EACpF,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS,mCAAmC,CAAC,CAAC,SAAS;EACxE,qBAAqB,EAAE,OAAO,CAAC,CAAC,SAAS,6CAA6C,CAAC,CAAC,SAAS;CACnG,CAAC,CAAC,CAAC,SAAS,mEAOF;AACV,CAAC"}

package/dist/actions/create-api-access-keys.cjs

@@ -16,14 +16,14 @@ const NewRelicCreateApiAccessKeysInput = zod.z.object({
 	}).describe("Input parameters for creating an ingest API key.").optional()
 }).describe("Request model for creating API access keys in New Relic.");
 const NewRelicCreateApiAccessKeys_KeyCreationErrorSchema = zod.z.object({
-	type: zod.z.string().describe("Error type or category (e.g., VALIDATION_ERROR)."),
-	message: zod.z.string().describe("Error message describing what went wrong.")
+	type: zod.z.string().describe("Error type or category (e.g., VALIDATION_ERROR).").nullable(),
+	message: zod.z.string().describe("Error message describing what went wrong.").nullable()
 }).describe("Error details if key creation failed.");
 const NewRelicCreateApiAccessKeys_CreatedKeySchema = zod.z.object({
-	id: zod.z.string().describe("Unique identifier for the created key."),
-	key: zod.z.string().describe("The actual API key value. Store this securely."),
+	id: zod.z.string().describe("Unique identifier for the created key.").nullable(),
+	key: zod.z.string().describe("The actual API key value. Store this securely.").nullable(),
 	name: zod.z.string().describe("Name of the key, if provided during creation.").nullable().optional(),
-	type: zod.z.string().describe("The type of key created (e.g., USER, INGEST)."),
+	type: zod.z.string().describe("The type of key created (e.g., USER, INGEST).").nullable(),
 	notes: zod.z.string().describe("Notes for the key, if provided during creation.").nullable().optional(),
 	created_at: zod.z.number().int().describe("Timestamp (Unix timestamp in milliseconds) when the key was created.").nullable().optional()
 }).describe("Details of a successfully created API key.");