@automate.ax/integration-contracts 0.104.0 → 0.107.0

package/dist/cloudflare/schemas.js

@@ -0,0 +1,340 @@
+import * as z from "zod";
+import { encodableSchema } from "@automate.ax/codec";
+const IDENTIFIER_SCHEMA = z.string().trim().min(1).max(32);
+const RESPONSE_INFO_SCHEMA = z.object({
+    code: z.number().optional(),
+    documentationUrl: z.string().optional(),
+    message: z.string(),
+    source: z.object({ pointer: z.string().optional() }).optional(),
+});
+export const CLOUDFLARE_PAGE_INFO_SCHEMA = z.object({
+    count: z.number().int().nonnegative().optional(),
+    page: z.number().int().positive().optional(),
+    perPage: z.number().int().positive().optional(),
+    totalCount: z.number().int().nonnegative().optional(),
+    totalPages: z.number().int().nonnegative().optional(),
+});
+export const CLOUDFLARE_ACCOUNT_SCHEMA = z.object({
+    id: IDENTIFIER_SCHEMA,
+    name: z.string().min(1),
+    settings: z
+        .object({
+        abuseContactEmail: z.string().nullable().optional(),
+        enforceTwoFactor: z.boolean().optional(),
+    })
+        .optional(),
+    type: z.enum(["enterprise", "standard"]).optional(),
+});
+export const CLOUDFLARE_ZONE_SCHEMA = z.object({
+    account: z.object({
+        id: IDENTIFIER_SCHEMA,
+        name: z.string().optional(),
+    }),
+    activatedOn: z.string().nullable().optional(),
+    createdOn: z.string(),
+    developmentMode: z.number(),
+    id: IDENTIFIER_SCHEMA,
+    meta: z.object({
+        cdnOnly: z.boolean().optional(),
+        customCertificateQuota: z.number().int().optional(),
+        dnsOnly: z.boolean().optional(),
+        foundationDns: z.boolean().optional(),
+        pageRuleQuota: z.number().int().optional(),
+        phishingDetected: z.boolean().optional(),
+        step: z.number().int().optional(),
+    }),
+    modifiedOn: z.string(),
+    name: z.string().min(1).max(253),
+    nameServers: z.string().array(),
+    originalDnshost: z.string().nullable().optional(),
+    originalNameServers: z.string().array().nullable().optional(),
+    originalRegistrar: z.string().nullable().optional(),
+    paused: z.boolean(),
+    status: z.enum(["active", "initializing", "moved", "pending"]),
+    type: z.enum(["full", "internal", "partial", "secondary"]),
+    vanityNameServers: z.string().array().optional(),
+});
+export const CLOUDFLARE_DNS_RECORD_TYPE_SCHEMA = z.enum([
+    "A",
+    "AAAA",
+    "CAA",
+    "CERT",
+    "CNAME",
+    "DNSKEY",
+    "DS",
+    "HTTPS",
+    "LOC",
+    "MX",
+    "NAPTR",
+    "NS",
+    "OPENPGPKEY",
+    "PTR",
+    "SMIMEA",
+    "SRV",
+    "SSHFP",
+    "SVCB",
+    "TLSA",
+    "TXT",
+    "URI",
+]);
+export const CLOUDFLARE_DNS_RECORD_SCHEMA = z.object({
+    comment: z.string().nullable().optional(),
+    commentModifiedOn: z.string().nullable().optional(),
+    content: z.string(),
+    createdOn: z.string(),
+    data: z.record(z.string(), encodableSchema).optional(),
+    id: IDENTIFIER_SCHEMA,
+    meta: z.record(z.string(), encodableSchema).optional(),
+    modifiedOn: z.string(),
+    name: z.string().min(1).max(255),
+    priority: z.number().int().min(0).max(65_535).optional(),
+    proxiable: z.boolean(),
+    proxied: z.boolean(),
+    settings: z.record(z.string(), encodableSchema).optional(),
+    tags: z.string().array().optional(),
+    tagsModifiedOn: z.string().nullable().optional(),
+    ttl: z.number().int().nonnegative(),
+    type: CLOUDFLARE_DNS_RECORD_TYPE_SCHEMA,
+});
+export const CLOUDFLARE_HEALTH_CHECK_REGION_SCHEMA = z.enum([
+    "ALL_REGIONS",
+    "EEU",
+    "ENAM",
+    "IN",
+    "ME",
+    "NAF",
+    "NEAS",
+    "NSAM",
+    "OC",
+    "SAF",
+    "SEAS",
+    "SSAM",
+    "WEU",
+    "WNAM",
+]);
+export const CLOUDFLARE_HTTP_HEALTH_CHECK_SCHEMA = z.object({
+    allowInsecure: z.boolean().optional(),
+    expectedBody: z.string().optional(),
+    expectedCodes: z.string().array().nullable().optional(),
+    followRedirects: z.boolean().optional(),
+    header: z.record(z.string(), z.string().array()).nullable().optional(),
+    method: z.enum(["GET", "HEAD"]).optional(),
+    path: z.string().optional(),
+    port: z.number().int().min(0).max(65_535).optional(),
+});
+export const CLOUDFLARE_TCP_HEALTH_CHECK_SCHEMA = z.object({
+    method: z.literal("connection_established").optional(),
+    port: z.number().int().min(0).max(65_535).optional(),
+});
+export const CLOUDFLARE_HEALTH_CHECK_SCHEMA = z.object({
+    address: z.string(),
+    checkRegions: CLOUDFLARE_HEALTH_CHECK_REGION_SCHEMA.array()
+        .nullable()
+        .optional(),
+    consecutiveFails: z.number().int().nonnegative().optional(),
+    consecutiveSuccesses: z.number().int().nonnegative().optional(),
+    createdOn: z.string().optional(),
+    description: z.string().optional(),
+    failureReason: z.string().optional(),
+    httpConfig: CLOUDFLARE_HTTP_HEALTH_CHECK_SCHEMA.nullable().optional(),
+    id: IDENTIFIER_SCHEMA.optional(),
+    interval: z.number().int().nonnegative().optional(),
+    modifiedOn: z.string().optional(),
+    name: z.string().regex(/^[A-Za-z0-9_-]+$/),
+    retries: z.number().int().nonnegative().optional(),
+    status: z.enum(["healthy", "suspended", "unknown", "unhealthy"]).optional(),
+    suspended: z.boolean().optional(),
+    tcpConfig: CLOUDFLARE_TCP_HEALTH_CHECK_SCHEMA.nullable().optional(),
+    timeout: z.number().int().nonnegative().optional(),
+    type: z.enum(["HTTP", "HTTPS", "TCP"]).optional(),
+});
+export const CLOUDFLARE_ALERT_TYPE_SCHEMA = z.enum([
+    "abuse_report_alert",
+    "access_custom_certificate_expiration_type",
+    "advanced_ddos_attack_l4_alert",
+    "advanced_ddos_attack_l7_alert",
+    "advanced_http_alert_error",
+    "bgp_hijack_notification",
+    "billing_usage_alert",
+    "block_notification_block_removed",
+    "block_notification_new_block",
+    "block_notification_review_rejected",
+    "bot_traffic_basic_alert",
+    "brand_protection_alert",
+    "brand_protection_digest",
+    "clickhouse_alert_fw_anomaly",
+    "clickhouse_alert_fw_ent_anomaly",
+    "cloudforce_one_request_notification",
+    "cni_maintenance_notification",
+    "custom_analytics",
+    "custom_bot_detection_alert",
+    "custom_ssl_certificate_event_type",
+    "dedicated_ssl_certificate_event_type",
+    "device_connectivity_anomaly_alert",
+    "dos_attack_l4",
+    "dos_attack_l7",
+    "expiring_service_token_alert",
+    "failing_logpush_job_disabled_alert",
+    "fbm_auto_advertisement",
+    "fbm_dosd_attack",
+    "fbm_volumetric_attack",
+    "health_check_status_notification",
+    "hostname_aop_custom_certificate_expiration_type",
+    "http_alert_edge_error",
+    "http_alert_origin_error",
+    "image_notification",
+    "image_resizing_notification",
+    "incident_alert",
+    "load_balancing_health_alert",
+    "load_balancing_pool_enablement_alert",
+    "logo_match_alert",
+    "magic_tunnel_health_check_event",
+    "magic_wan_tunnel_health",
+    "maintenance_event_notification",
+    "mtls_certificate_store_certificate_expiration_type",
+    "pages_event_alert",
+    "radar_notification",
+    "real_origin_monitoring",
+    "scriptmonitor_alert_new_code_change_detections",
+    "scriptmonitor_alert_new_hosts",
+    "scriptmonitor_alert_new_malicious_hosts",
+    "scriptmonitor_alert_new_malicious_scripts",
+    "scriptmonitor_alert_new_malicious_url",
+    "scriptmonitor_alert_new_max_length_resource_url",
+    "scriptmonitor_alert_new_resources",
+    "secondary_dns_all_primaries_failing",
+    "secondary_dns_primaries_failing",
+    "secondary_dns_warning",
+    "secondary_dns_zone_successfully_updated",
+    "secondary_dns_zone_validation_warning",
+    "security_insights_alert",
+    "sentinel_alert",
+    "stream_live_notifications",
+    "synthetic_test_latency_alert",
+    "synthetic_test_low_availability_alert",
+    "traffic_anomalies_alert",
+    "tunnel_health_event",
+    "tunnel_update_event",
+    "universal_ssl_event_type",
+    "web_analytics_metrics_update",
+    "zone_aop_custom_certificate_expiration_type",
+]);
+const STRING_FILTER_SCHEMA = z.string().min(1).array().min(1);
+export const CLOUDFLARE_NOTIFICATION_FILTERS_SCHEMA = z.object({
+    actions: STRING_FILTER_SCHEMA.optional(),
+    affectedAsns: STRING_FILTER_SCHEMA.optional(),
+    affectedComponents: STRING_FILTER_SCHEMA.optional(),
+    affectedLocations: STRING_FILTER_SCHEMA.optional(),
+    airportCode: STRING_FILTER_SCHEMA.optional(),
+    alertTriggerPreferences: STRING_FILTER_SCHEMA.optional(),
+    alertTriggerPreferencesValue: STRING_FILTER_SCHEMA.optional(),
+    enabled: STRING_FILTER_SCHEMA.optional(),
+    environment: STRING_FILTER_SCHEMA.optional(),
+    event: STRING_FILTER_SCHEMA.optional(),
+    eventSource: STRING_FILTER_SCHEMA.optional(),
+    eventType: STRING_FILTER_SCHEMA.optional(),
+    groupBy: STRING_FILTER_SCHEMA.optional(),
+    healthCheckId: STRING_FILTER_SCHEMA.optional(),
+    incidentImpact: z
+        .enum([
+        "INCIDENT_IMPACT_CRITICAL",
+        "INCIDENT_IMPACT_MAJOR",
+        "INCIDENT_IMPACT_MINOR",
+        "INCIDENT_IMPACT_NONE",
+    ])
+        .array()
+        .min(1)
+        .optional(),
+    inputId: STRING_FILTER_SCHEMA.optional(),
+    insightClass: STRING_FILTER_SCHEMA.optional(),
+    limit: STRING_FILTER_SCHEMA.optional(),
+    logoTag: STRING_FILTER_SCHEMA.optional(),
+    megabitsPerSecond: STRING_FILTER_SCHEMA.optional(),
+    newHealth: STRING_FILTER_SCHEMA.optional(),
+    newStatus: STRING_FILTER_SCHEMA.optional(),
+    packetsPerSecond: STRING_FILTER_SCHEMA.optional(),
+    poolId: STRING_FILTER_SCHEMA.optional(),
+    popNames: STRING_FILTER_SCHEMA.optional(),
+    product: STRING_FILTER_SCHEMA.optional(),
+    projectId: STRING_FILTER_SCHEMA.optional(),
+    protocol: STRING_FILTER_SCHEMA.optional(),
+    queryTag: STRING_FILTER_SCHEMA.optional(),
+    requestsPerSecond: STRING_FILTER_SCHEMA.optional(),
+    selectors: STRING_FILTER_SCHEMA.optional(),
+    services: STRING_FILTER_SCHEMA.optional(),
+    slo: STRING_FILTER_SCHEMA.optional(),
+    status: STRING_FILTER_SCHEMA.optional(),
+    targetHostname: STRING_FILTER_SCHEMA.optional(),
+    targetIp: STRING_FILTER_SCHEMA.optional(),
+    targetZoneName: STRING_FILTER_SCHEMA.optional(),
+    trafficExclusions: z.literal("security_events").array().max(1).optional(),
+    tunnelId: STRING_FILTER_SCHEMA.optional(),
+    tunnelName: STRING_FILTER_SCHEMA.optional(),
+    type: STRING_FILTER_SCHEMA.optional(),
+    where: STRING_FILTER_SCHEMA.optional(),
+    zones: STRING_FILTER_SCHEMA.optional(),
+});
+export const CLOUDFLARE_NOTIFICATION_MECHANISMS_SCHEMA = z.object({
+    email: z.object({ id: z.email() }).array().optional(),
+    pagerduty: z
+        .object({ id: z.string().min(1) })
+        .array()
+        .optional(),
+    webhooks: z
+        .object({ id: z.string().min(1) })
+        .array()
+        .optional(),
+});
+export const CLOUDFLARE_NOTIFICATION_POLICY_SCHEMA = z.object({
+    alertInterval: z.string().optional(),
+    alertType: CLOUDFLARE_ALERT_TYPE_SCHEMA,
+    created: z.string().optional(),
+    description: z.string().optional(),
+    enabled: z.boolean(),
+    filters: CLOUDFLARE_NOTIFICATION_FILTERS_SCHEMA.optional(),
+    id: z.string().min(1).optional(),
+    mechanisms: CLOUDFLARE_NOTIFICATION_MECHANISMS_SCHEMA,
+    modified: z.string().optional(),
+    name: z.string().min(1),
+});
+export const CLOUDFLARE_AVAILABLE_ALERT_SCHEMA = z.object({
+    description: z.string().optional(),
+    displayName: z.string().optional(),
+    filterOptions: encodableSchema.optional(),
+    type: CLOUDFLARE_ALERT_TYPE_SCHEMA,
+});
+export const CLOUDFLARE_NOTIFICATION_HISTORY_SCHEMA = z.object({
+    alertBody: z.string().optional(),
+    alertType: z.string().optional(),
+    description: z.string().optional(),
+    id: z.string().optional(),
+    mechanism: z.string().optional(),
+    mechanismType: z.enum(["email", "pagerduty", "webhook"]).optional(),
+    name: z.string().optional(),
+    policyId: z.string().optional(),
+    sent: z.string().optional(),
+});
+export const CLOUDFLARE_DELETE_RESULT_SCHEMA = z.object({
+    id: z.string().min(1),
+});
+export const CLOUDFLARE_NOTIFICATION_WEBHOOK_SCHEMA = z.object({
+    createdAt: z.string().optional(),
+    id: z.string().min(1),
+    lastFailure: z.string().optional(),
+    lastSuccess: z.string().optional(),
+    name: z.string().optional(),
+    type: z
+        .enum([
+        "datadog",
+        "discord",
+        "feishu",
+        "gchat",
+        "generic",
+        "opsgenie",
+        "slack",
+        "splunk",
+    ])
+        .optional(),
+    url: z.string().optional(),
+});
+export const CLOUDFLARE_API_RESPONSE_INFO_SCHEMA = RESPONSE_INFO_SCHEMA;

package/dist/linear/api.d.ts

@@ -58,6 +58,6 @@ export declare class LinearApiError extends Error {
  * action. OAuth access tokens are resolved by the platform and never exposed to
  * automation code.
  *
- * @param secret - Resolved Linear OAuth integration secret.
+ * @param secret - Resolved Linear OAuth or personal API-key secret.
  */
 export declare function getLinearApi(secret: Record<string, unknown>): LinearApi;

package/dist/linear/api.js

@@ -1,8 +1,9 @@
 import * as z from "zod";
 const LINEAR_GRAPHQL_URL = "https://api.linear.app/graphql";
-const LINEAR_SECRET_SCHEMA = z.object({
-    accessToken: z.string().min(1),
-});
+const LINEAR_SECRET_SCHEMA = z.union([
+    z.object({ accessToken: z.string().min(1) }),
+    z.object({ apiKey: z.string().min(1) }),
+]);
 const LINEAR_ERROR_SCHEMA = z.looseObject({
     extensions: z.record(z.string(), z.json()).optional(),
     message: z.string(),
@@ -43,10 +44,10 @@ export class LinearApiError extends Error {
  * action. OAuth access tokens are resolved by the platform and never exposed to
  * automation code.
  *
- * @param secret - Resolved Linear OAuth integration secret.
+ * @param secret - Resolved Linear OAuth or personal API-key secret.
  */
 export function getLinearApi(secret) {
-    const { accessToken } = LINEAR_SECRET_SCHEMA.parse(secret);
+    const credential = LINEAR_SECRET_SCHEMA.parse(secret);
     return {
         graphql: async (document, options) => {
             const response = await fetch(LINEAR_GRAPHQL_URL, {
@@ -56,7 +57,9 @@ export function getLinearApi(secret) {
                 }),
                 headers: {
                     Accept: "application/json",
-                    Authorization: `Bearer ${accessToken}`,
+                    Authorization: "accessToken" in credential
+                        ? `Bearer ${credential.accessToken}`
+                        : credential.apiKey,
                     "Content-Type": "application/json",
                 },
                 method: "POST",