@automate.ax/integration-contracts 0.125.0 → 0.127.0

package/dist/axiom/schemas.js

@@ -0,0 +1,580 @@
+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/dist/brevo/index.d.ts

@@ -215,9 +215,9 @@ export declare const brevoTriggerContracts: {
         }, z.core.$strip>, z.ZodObject<{
             family: z.ZodLiteral<"contact">;
             type: z.ZodEnum<{
+                updated: "updated";
                 deleted: "deleted";
                 addedToList: "addedToList";
-                updated: "updated";
             }>;
             bounceType: z.ZodOptional<z.ZodString>;
             campaignId: z.ZodOptional<z.ZodNumber>;
@@ -1610,9 +1610,9 @@ export declare const brevoTriggerContracts: {
         eventSchema: z.ZodObject<{
             family: z.ZodLiteral<"contact">;
             type: z.ZodEnum<{
+                updated: "updated";
                 deleted: "deleted";
                 addedToList: "addedToList";
-                updated: "updated";
             }>;
             bounceType: z.ZodOptional<z.ZodString>;
             campaignId: z.ZodOptional<z.ZodNumber>;

package/dist/brevo/schemas.d.ts

@@ -219,9 +219,9 @@ export declare const BREVO_MARKETING_SMS_EVENT_SCHEMA: z.ZodObject<{
 export declare const BREVO_CONTACT_EVENT_SCHEMA: z.ZodObject<{
     family: z.ZodLiteral<"contact">;
     type: z.ZodEnum<{
+        updated: "updated";
         deleted: "deleted";
         addedToList: "addedToList";
-        updated: "updated";
     }>;
     bounceType: z.ZodOptional<z.ZodString>;
     campaignId: z.ZodOptional<z.ZodNumber>;
@@ -474,9 +474,9 @@ export declare const BREVO_EVENT_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
     family: z.ZodLiteral<"contact">;
     type: z.ZodEnum<{
+        updated: "updated";
         deleted: "deleted";
         addedToList: "addedToList";
-        updated: "updated";
     }>;
     bounceType: z.ZodOptional<z.ZodString>;
     campaignId: z.ZodOptional<z.ZodNumber>;
@@ -744,7 +744,7 @@ export declare function normalizeBrevoEvent(value: unknown, webhookId?: number):
     userAgent?: string | undefined;
 } | {
     family: "contact";
-    type: "deleted" | "addedToList" | "updated";
+    type: "updated" | "deleted" | "addedToList";
     event: Record<string, z.core.util.JSONType>;
     webhookId: number;
     bounceType?: string | undefined;