@automate.ax/integration-contracts 0.126.0 → 0.127.0

package/src/axiom/schemas.ts

@@ -0,0 +1,614 @@
+import { encodableSchema } from "@automate.ax/codec"
+import * as z from "zod"
+
+export const AXIOM_ID_SCHEMA = z.string().trim().min(1)
+export const AXIOM_DEFAULT_EDGE_ORIGIN = "https://us-east-1.aws.edge.axiom.co"
+export const AXIOM_EDGE_URL_SCHEMA = z
+  .url()
+  .refine((value) => {
+    const url = new URL(value)
+    return (
+      url.protocol === "https:" &&
+      url.port === "" &&
+      url.hostname.endsWith(".edge.axiom.co") &&
+      !url.username &&
+      !url.password &&
+      url.pathname === "/" &&
+      !url.search &&
+      !url.hash
+    )
+  }, "Use the HTTPS base origin of an Axiom edge deployment.")
+  .prefault(AXIOM_DEFAULT_EDGE_ORIGIN)
+export const AXIOM_TIME_SCHEMA = z.string().trim().min(1)
+export const AXIOM_DATASET_KIND_SCHEMA = z.enum([
+  "axiom:events:v1",
+  "otel:logs:v1",
+  "otel:metrics:v1",
+  "otel:traces:v1",
+])
+export const AXIOM_DATASET_FIELD_SCHEMA = z.object({
+  description: z.string().optional(),
+  hidden: z.boolean().optional(),
+  name: AXIOM_ID_SCHEMA,
+  type: z.string().min(1),
+  unit: z.string().optional(),
+})
+
+export const AXIOM_INGEST_STATUS_SCHEMA = z
+  .object({
+    blocksCreated: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+    failures: z
+      .object({
+        error: z.string(),
+        timestamp: z.string(),
+      })
+      .catchall(encodableSchema)
+      .array()
+      .optional(),
+    ingested: z.number().int().nonnegative(),
+    processedBytes: z.number().int().nonnegative(),
+    walLength: z.number().int().nonnegative(),
+  })
+  .catchall(encodableSchema)
+
+export const AXIOM_QUERY_OPTIONS_SCHEMA = z.object({
+  disableCache: z.boolean().optional(),
+  disableStats: z.boolean().optional(),
+  disableTrace: z.boolean().optional(),
+  displayNull: z.enum(["", "auto", "null", "span", "zero"]).optional(),
+  maxDataPoints: z.number().int().positive().optional(),
+  maxSeries: z.number().int().positive().optional(),
+  noAggregation: z.boolean().optional(),
+  noFill: z.boolean().optional(),
+  noInterpolation: z.boolean().optional(),
+  priority: z.enum(["high", "low", "medium"]).optional(),
+  resolution: z.string().optional(),
+  shownColumns: z.string().max(10_000).optional(),
+  timeSeriesVariant: z.enum(["", "area", "bars", "line", "lines"]).optional(),
+  timeSeriesView: z
+    .enum(["", "charts", "charts|resultsTable", "resultsTable"])
+    .optional(),
+})
+
+export const AXIOM_APL_REQUEST_SCHEMA = z.object({
+  apl: z.string().trim().min(1),
+  cursor: z.string().optional(),
+  defaultLimit: z.number().int().positive().optional(),
+  defaultOrder: z
+    .object({ desc: z.boolean().optional(), field: z.string().min(1) })
+    .array()
+    .optional(),
+  endTime: AXIOM_TIME_SCHEMA.prefault("now"),
+  includeCursor: z.boolean().optional(),
+  includeCursorField: z.boolean().optional(),
+  libraries: AXIOM_ID_SCHEMA.array().optional(),
+  queryOptions: AXIOM_QUERY_OPTIONS_SCHEMA.optional(),
+  startTime: AXIOM_TIME_SCHEMA.prefault("now-30m"),
+  variables: z.record(z.string(), z.record(z.string(), z.json())).optional(),
+})
+
+const AXIOM_QUERY_MESSAGE_SCHEMA = z.object({
+  code: z.string().optional(),
+  count: z.number().int(),
+  msg: z.string(),
+  priority: z.string(),
+})
+
+export const AXIOM_QUERY_RESULT_SCHEMA = z
+  .object({
+    datasetNames: z.string().array(),
+    fieldsMetaMap: z
+      .record(
+        z.string(),
+        z
+          .object({
+            description: z.string().optional(),
+            hidden: z.boolean().optional(),
+            name: z.string(),
+            type: z.string(),
+            unit: z.string().optional(),
+          })
+          .catchall(encodableSchema)
+          .array(),
+      )
+      .optional(),
+    format: z.literal("tabular"),
+    status: z
+      .object({
+        blocksExamined: z.number().int().nonnegative(),
+        cacheStatus: z.number().int().nonnegative(),
+        continuationToken: z.string().optional(),
+        elapsedTime: z.number().int().nonnegative(),
+        isEstimate: z.boolean().optional(),
+        isPartial: z.boolean(),
+        maxBlockTime: z.string(),
+        maxCursor: z.string().optional(),
+        messages: AXIOM_QUERY_MESSAGE_SCHEMA.array().optional(),
+        minBlockTime: z.string(),
+        minCursor: z.string().optional(),
+        numGroups: z.number().int().nonnegative(),
+        rowsExamined: z.number().int().nonnegative(),
+        rowsMatched: z.number().int().nonnegative(),
+      })
+      .catchall(encodableSchema),
+    tables: z
+      .object({
+        buckets: z
+          .object({
+            field: z.string(),
+            size: z.number(),
+          })
+          .optional(),
+        columns: z.json().array().array().optional(),
+        fields: z
+          .object({
+            agg: z.record(z.string(), encodableSchema).optional(),
+            name: z.string(),
+            type: z.string(),
+          })
+          .array(),
+        groups: z.object({ name: z.string().optional() }).array(),
+        name: z.string(),
+        order: z.object({ desc: z.boolean(), field: z.string() }).array(),
+        range: z
+          .object({
+            end: z.string(),
+            field: z.string(),
+            start: z.string(),
+          })
+          .optional(),
+        sources: z.object({ name: z.string() }).array(),
+      })
+      .catchall(encodableSchema)
+      .array(),
+  })
+  .catchall(encodableSchema)
+
+export const AXIOM_METRICS_RESULT_SCHEMA = z.record(z.string(), z.json())
+export const AXIOM_METRIC_INFO_SCHEMA = z.object({
+  temporality: z.string(),
+  type: z.string(),
+  unit: z.string().nullable(),
+})
+export const AXIOM_METRICS_INFO_SCHEMA = z.record(
+  z.string(),
+  AXIOM_METRIC_INFO_SCHEMA,
+)
+export const AXIOM_METRIC_DISCOVERY_SCHEMA = z.object({
+  datasetName: AXIOM_ID_SCHEMA,
+  edgeUrl: AXIOM_EDGE_URL_SCHEMA,
+  endTime: AXIOM_TIME_SCHEMA.prefault("now"),
+  startTime: AXIOM_TIME_SCHEMA.prefault("now-30m"),
+})
+export const AXIOM_METRIC_TAG_DISCOVERY_SCHEMA =
+  AXIOM_METRIC_DISCOVERY_SCHEMA.extend({
+    metric: AXIOM_ID_SCHEMA,
+  })
+export const AXIOM_DATASET_TAG_VALUE_DISCOVERY_SCHEMA =
+  AXIOM_METRIC_DISCOVERY_SCHEMA.extend({
+    tag: AXIOM_ID_SCHEMA,
+  })
+export const AXIOM_METRIC_TAG_VALUE_DISCOVERY_SCHEMA =
+  AXIOM_METRIC_TAG_DISCOVERY_SCHEMA.extend({
+    tag: AXIOM_ID_SCHEMA,
+  })
+
+export const AXIOM_DATASET_SCHEMA = z
+  .object({
+    canWrite: z.boolean().optional(),
+    created: z.string(),
+    description: z.string(),
+    edgeDeployment: z.string().optional(),
+    edgeDeploymentUrl: z.string().optional(),
+    id: AXIOM_ID_SCHEMA,
+    kind: AXIOM_DATASET_KIND_SCHEMA,
+    mapFields: z.string().array().optional(),
+    name: AXIOM_ID_SCHEMA,
+    retentionDays: z.number().int().nonnegative().optional(),
+    sharedByOrg: z.string().optional(),
+    updatedAt: z.string(),
+    useRetentionPeriod: z.boolean().optional(),
+    who: z.string(),
+  })
+  .catchall(encodableSchema)
+
+export const AXIOM_ANNOTATION_SCHEMA = z.object({
+  datasets: AXIOM_ID_SCHEMA.array().min(1),
+  description: z.string().max(512).optional(),
+  endTime: z.string().nullable().optional(),
+  id: AXIOM_ID_SCHEMA,
+  time: z.string(),
+  title: z.string().max(256).optional(),
+  type: z
+    .string()
+    .regex(/^[a-z0-9-]+$/)
+    .max(256),
+  url: z.string().max(512).optional(),
+})
+
+export const AXIOM_MONITOR_TYPE_SCHEMA = z.enum([
+  "AnomalyDetection",
+  "MatchEvent",
+  "Threshold",
+])
+export const AXIOM_MONITOR_SCHEMA = z
+  .object({
+    alertOnNoData: z.boolean().optional(),
+    aplQuery: z.string().trim().min(1).optional(),
+    columnName: z.string().optional(),
+    compareDays: z.number().int().min(1).max(7).optional(),
+    description: z.string().optional(),
+    disabled: z.boolean().optional(),
+    disabledUntil: z.string().nullable().optional(),
+    intervalMinutes: z.number().int().positive(),
+    mplQuery: z.string().trim().min(1).optional(),
+    name: z.string().trim().min(1),
+    notifierIds: AXIOM_ID_SCHEMA.array().optional(),
+    notifyByGroup: z.boolean().optional(),
+    notifyEveryRun: z.boolean().optional(),
+    operator: z
+      .enum(["Above", "AboveOrBelow", "AboveOrEqual", "Below", "BelowOrEqual"])
+      .optional(),
+    rangeMinutes: z.number().int().positive(),
+    resolvable: z.boolean().optional(),
+    secondDelay: z.number().int().min(0).max(86_400).optional(),
+    skipResolved: z.boolean().optional(),
+    threshold: z.number().optional(),
+    tolerance: z.number().min(0).max(100).optional(),
+    triggerAfterNPositiveResults: z.number().int().positive().optional(),
+    triggerFromNRuns: z.number().int().positive().optional(),
+    type: AXIOM_MONITOR_TYPE_SCHEMA,
+  })
+  .refine(({ aplQuery, mplQuery }) => Boolean(aplQuery) !== Boolean(mplQuery), {
+    message: "Provide exactly one of aplQuery or mplQuery.",
+  })
+export const AXIOM_MONITOR_WITH_ID_SCHEMA = AXIOM_MONITOR_SCHEMA.and(
+  z
+    .object({
+      createdAt: z.string().optional(),
+      createdBy: z.string().optional(),
+      id: AXIOM_ID_SCHEMA,
+      updatedAt: z.string().optional(),
+    })
+    .catchall(encodableSchema),
+)
+
+export const AXIOM_ALERT_HISTORY_SCHEMA = z.object({
+  checkId: AXIOM_ID_SCHEMA,
+  name: z.string(),
+  state: z.enum(["closed", "open"]),
+  timestamp: z.string(),
+})
+
+const HEADER_MAP_SCHEMA = z.record(z.string().min(1), z.string())
+export const AXIOM_NOTIFIER_PROPERTIES_SCHEMA = z.union([
+  z.object({ email: z.object({ emails: z.email().array().min(1) }) }),
+  z.object({ slack: z.object({ slackUrl: z.url() }) }),
+  z.object({ webhook: z.object({ url: z.url() }) }),
+  z.object({
+    customWebhook: z.object({
+      body: z.string().min(1),
+      headers: HEADER_MAP_SCHEMA.optional(),
+      secretHeaders: HEADER_MAP_SCHEMA.optional(),
+      url: z.url(),
+    }),
+  }),
+  z.object({
+    pagerduty: z.object({
+      routingKey: z.string().min(1).optional(),
+      token: z.string().min(1).optional(),
+    }),
+  }),
+  z.object({
+    opsgenie: z.object({
+      apiKey: z.string().min(1),
+      isEU: z.boolean().optional(),
+    }),
+  }),
+  z.object({
+    discord: z.object({
+      discordChannel: z.string().min(1),
+      discordToken: z.string().min(1),
+    }),
+  }),
+  z.object({ discordWebhook: z.object({ discordWebhookUrl: z.url() }) }),
+  z.object({ microsoftTeams: z.object({ microsoftTeamsUrl: z.url() }) }),
+])
+
+export const AXIOM_NOTIFIER_SCHEMA = z
+  .object({
+    createdAt: z.string().optional(),
+    createdBy: z.string().optional(),
+    disabledUntil: z.string().nullable().optional(),
+    id: AXIOM_ID_SCHEMA.optional(),
+    name: z.string().trim().min(1),
+    properties: AXIOM_NOTIFIER_PROPERTIES_SCHEMA,
+    updatedAt: z.string().optional(),
+  })
+  .catchall(encodableSchema)
+export const AXIOM_NOTIFIER_WITH_ID_SCHEMA = AXIOM_NOTIFIER_SCHEMA.extend({
+  id: AXIOM_ID_SCHEMA,
+})
+
+export const AXIOM_SAVED_QUERY_SCHEMA = z.object({
+  dataset: z.string().optional(),
+  id: AXIOM_ID_SCHEMA.optional(),
+  kind: z.literal("apl"),
+  metadata: z.record(z.string(), z.string()),
+  name: z.string().trim().min(1),
+  query: AXIOM_APL_REQUEST_SCHEMA,
+  who: z.string(),
+})
+export const AXIOM_SAVED_QUERY_WITH_ID_SCHEMA = AXIOM_SAVED_QUERY_SCHEMA.extend(
+  {
+    id: AXIOM_ID_SCHEMA,
+  },
+)
+
+const AXIOM_CHART_QUERY_SCHEMA = z
+  .object({
+    apl: z.string().trim().min(1).optional(),
+    mpl: z.string().trim().min(1).optional(),
+    queryOptions: z.record(z.string(), encodableSchema).optional(),
+  })
+  .catchall(encodableSchema)
+  .refine(({ apl, mpl }) => Boolean(apl) !== Boolean(mpl), {
+    message: "Provide exactly one of query.apl or query.mpl.",
+  })
+const AXIOM_DASHBOARD_CHART_FIELDS = {
+  id: AXIOM_ID_SCHEMA,
+  name: z.string().min(1).max(500).optional(),
+  sectionId: z.uuid().optional(),
+}
+const AXIOM_DASHBOARD_QUERY_CHART_FIELDS = {
+  ...AXIOM_DASHBOARD_CHART_FIELDS,
+  query: AXIOM_CHART_QUERY_SCHEMA,
+}
+const AXIOM_STATISTIC_COLOR_SCHEMA = z.string().max(200)
+const AXIOM_STATISTIC_COLOR_PROPS_SCHEMA = z.object({
+  background: AXIOM_STATISTIC_COLOR_SCHEMA.optional(),
+  chartFillColor: AXIOM_STATISTIC_COLOR_SCHEMA.optional(),
+  labelColor: AXIOM_STATISTIC_COLOR_SCHEMA.optional(),
+  textColor: AXIOM_STATISTIC_COLOR_SCHEMA.optional(),
+})
+const AXIOM_STATISTIC_THRESHOLD_SCHEMA = z.enum([
+  "Above",
+  "AboveOrEqual",
+  "Below",
+  "BelowOrEqual",
+  "AboveOrBelow",
+])
+const AXIOM_SMART_FILTER_BASE_FIELDS = {
+  active: z.boolean().optional(),
+  id: z.string().max(200),
+  name: z.string().max(200),
+}
+const AXIOM_SMART_FILTER_SCHEMA = z.discriminatedUnion("type", [
+  z.object({
+    ...AXIOM_SMART_FILTER_BASE_FIELDS,
+    type: z.literal("search"),
+  }),
+  z
+    .object({
+      ...AXIOM_SMART_FILTER_BASE_FIELDS,
+      options: z.json().optional(),
+      query: z.record(z.string(), encodableSchema).optional(),
+      selectType: z.enum(["list", "query"]),
+      type: z.literal("select"),
+    })
+    .catchall(encodableSchema),
+])
+
+export const AXIOM_DASHBOARD_CHART_SCHEMA = z.discriminatedUnion("type", [
+  z
+    .object({
+      ...AXIOM_DASHBOARD_QUERY_CHART_FIELDS,
+      type: z.literal("TimeSeries"),
+    })
+    .catchall(encodableSchema),
+  z
+    .object({
+      ...AXIOM_DASHBOARD_QUERY_CHART_FIELDS,
+      type: z.literal("Heatmap"),
+    })
+    .catchall(encodableSchema),
+  z
+    .object({
+      ...AXIOM_DASHBOARD_QUERY_CHART_FIELDS,
+      type: z.literal("LogStream"),
+    })
+    .catchall(encodableSchema),
+  z
+    .object({
+      ...AXIOM_DASHBOARD_QUERY_CHART_FIELDS,
+      type: z.literal("Pie"),
+    })
+    .catchall(encodableSchema),
+  z
+    .object({
+      ...AXIOM_DASHBOARD_QUERY_CHART_FIELDS,
+      type: z.literal("Scatter"),
+    })
+    .catchall(encodableSchema),
+  z
+    .object({
+      ...AXIOM_DASHBOARD_QUERY_CHART_FIELDS,
+      type: z.literal("Table"),
+    })
+    .catchall(encodableSchema),
+  z
+    .object({
+      ...AXIOM_DASHBOARD_QUERY_CHART_FIELDS,
+      type: z.literal("TopK"),
+    })
+    .catchall(encodableSchema),
+  z
+    .object({
+      ...AXIOM_DASHBOARD_QUERY_CHART_FIELDS,
+      background: AXIOM_STATISTIC_COLOR_SCHEMA.optional(),
+      chartFillColor: AXIOM_STATISTIC_COLOR_SCHEMA.optional(),
+      chartHeight: z.union([z.string().max(100), z.number()]).optional(),
+      colorScheme: z
+        .enum([
+          "Blue",
+          "Brown",
+          "Green",
+          "Grey",
+          "Orange",
+          "Pink",
+          "Purple",
+          "Red",
+          "Teal",
+          "Yellow",
+        ])
+        .optional(),
+      customUnits: z.string().max(200).optional(),
+      errorColorProps: AXIOM_STATISTIC_COLOR_PROPS_SCHEMA.optional(),
+      errorThreshold: AXIOM_STATISTIC_THRESHOLD_SCHEMA.optional(),
+      errorThresholdValue: z.string().max(100).optional(),
+      hideValue: z.boolean().optional(),
+      invertTheme: z.boolean().optional(),
+      labelColor: AXIOM_STATISTIC_COLOR_SCHEMA.optional(),
+      okColorProps: AXIOM_STATISTIC_COLOR_PROPS_SCHEMA.optional(),
+      showChart: z.union([z.boolean(), z.string()]).optional(),
+      textColor: AXIOM_STATISTIC_COLOR_SCHEMA.optional(),
+      type: z.literal("Statistic"),
+      warningColorProps: AXIOM_STATISTIC_COLOR_PROPS_SCHEMA.optional(),
+      warningThreshold: AXIOM_STATISTIC_THRESHOLD_SCHEMA.optional(),
+      warningThresholdValue: z.string().max(100).optional(),
+    })
+    .catchall(encodableSchema),
+  z
+    .object({
+      ...AXIOM_DASHBOARD_CHART_FIELDS,
+      text: z.string().min(1).max(100_000),
+      type: z.literal("Note"),
+      variant: z.literal("default").optional(),
+    })
+    .catchall(encodableSchema),
+  z
+    .object({
+      ...AXIOM_DASHBOARD_CHART_FIELDS,
+      columns: z.object({
+        dataset: z.boolean(),
+        history: z.boolean(),
+        notifiers: z.boolean(),
+        status: z.boolean(),
+        type: z.boolean(),
+      }),
+      selectedMonitors: z.string().min(1).max(200).array().min(1).max(200),
+      type: z.literal("MonitorList"),
+    })
+    .catchall(encodableSchema),
+  z
+    .object({
+      ...AXIOM_DASHBOARD_CHART_FIELDS,
+      filters: AXIOM_SMART_FILTER_SCHEMA.array().min(1).max(50),
+      logo: z.string().max(2_000).optional(),
+      logoDark: z.string().max(2_000).optional(),
+      type: z.literal("SmartFilter"),
+    })
+    .catchall(encodableSchema),
+  z
+    .object({
+      ...AXIOM_DASHBOARD_CHART_FIELDS,
+      type: z.literal("Spacer"),
+    })
+    .catchall(encodableSchema),
+])
+export const AXIOM_DASHBOARD_DOCUMENT_SCHEMA = z.object({
+  against: z
+    .enum([
+      "",
+      "-12h",
+      "-1d",
+      "-1h",
+      "-1w",
+      "-2w",
+      "-30d",
+      "-3d",
+      "-3h",
+      "-3w",
+      "-60d",
+      "-6h",
+      "-7d",
+      "-90d",
+    ])
+    .optional(),
+  againstTimestamp: z.string().max(100).optional(),
+  charts: AXIOM_DASHBOARD_CHART_SCHEMA.array().max(200),
+  description: z.string().max(1_000).optional(),
+  layout: z
+    .object({
+      h: z.number().int().min(1).max(100),
+      i: AXIOM_ID_SCHEMA,
+      maxH: z.number().int().min(1).max(100).optional(),
+      maxW: z.number().int().min(1).max(12).optional(),
+      minH: z.number().min(0.5).max(100).optional(),
+      minW: z.number().int().min(1).max(12).optional(),
+      static: z.boolean().optional(),
+      w: z.number().int().min(1).max(12),
+      x: z.number().int().min(0).max(11),
+      y: z.number().int().nonnegative().nullable(),
+    })
+    .array()
+    .max(200),
+  name: z.string().min(1).max(100),
+  owner: z.string().min(1),
+  refreshTime: z.union([z.literal(15), z.literal(60), z.literal(300)]),
+  schemaVersion: z.literal(2),
+  sections: z
+    .object({
+      defaultCollapsed: z.boolean().optional(),
+      id: z.uuid(),
+      title: z.string().min(1),
+    })
+    .array()
+    .optional(),
+  timeWindowEnd: z.string().min(1).max(100),
+  timeWindowStart: z.string().min(1).max(100),
+  uid: AXIOM_ID_SCHEMA.optional(),
+})
+
+export const AXIOM_DASHBOARD_RESOURCE_SCHEMA = z
+  .object({
+    createdAt: z.string(),
+    createdBy: z.string(),
+    dashboard: AXIOM_DASHBOARD_DOCUMENT_SCHEMA,
+    id: AXIOM_ID_SCHEMA,
+    uid: AXIOM_ID_SCHEMA,
+    updatedAt: z.string(),
+    updatedBy: z.string(),
+    version: z.number().int().positive(),
+  })
+  .catchall(encodableSchema)
+export const AXIOM_DASHBOARD_WRITE_SCHEMA = z.object({
+  dashboard: AXIOM_DASHBOARD_RESOURCE_SCHEMA,
+  overwritten: z.boolean().optional(),
+  status: z.enum(["created", "updated"]),
+})
+
+export const AXIOM_MONITOR_NOTIFICATION_SCHEMA = z.object({
+  action: z.enum(["Closed", "Open"]),
+  event: z.object({
+    body: z.string(),
+    description: z.string(),
+    groupKeys: z.string().array().nullable(),
+    groupValues: z.json().array().nullable(),
+    matchedEvent: z.record(z.string(), z.json()).nullable(),
+    monitorId: AXIOM_ID_SCHEMA,
+    queryEndTime: z.string(),
+    queryStartTime: z.string(),
+    timestamp: z.string(),
+    title: z.string(),
+    value: z.number(),
+  }),
+})
+
+export const AXIOM_EMPTY_SCHEMA = z.union([
+  z.null(),
+  z.object({}).transform(() => null),
+  z.undefined().transform(() => null),
+])
+export const AXIOM_JSON_OBJECT_SCHEMA = z.record(z.string(), encodableSchema)

package/src/triggers.ts

@@ -1,5 +1,6 @@
 import type { airtableTriggerContracts } from "./airtable"
 import type { apifyTriggerContracts } from "./apify"
+import type { axiomTriggerContracts } from "./axiom"
 import type { automateTriggerContracts } from "./automate"
 import type { asanaTriggerContracts } from "./asana"
 import type { brevoTriggerContracts } from "./brevo"
@@ -31,6 +32,7 @@ import type { z } from "zod"
 
 export type TriggerContractMap = typeof airtableTriggerContracts &
   typeof apifyTriggerContracts &
+  typeof axiomTriggerContracts &
   typeof automateTriggerContracts &
   typeof asanaTriggerContracts &
   typeof brevoTriggerContracts &