@automate.ax/catalog 0.111.1 → 0.112.4

package/dist/triggers/vercel.d.ts

@@ -10,6 +10,26 @@ export declare const vercelTriggerDefinitions: {
         readonly name: "Vercel deployment event";
         readonly type: "vercel.deployment";
     };
+    readonly vercelDeploymentCheckRerequested: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["deployment:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.deployment.checkRerequested";
+    };
+    readonly vercelDeploymentCleanup: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["deployment:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.deployment.cleanup";
+    };
     readonly vercelDeploymentCanceled: {
         readonly account: {
             readonly connectionOptions: readonly [{
@@ -50,6 +70,46 @@ export declare const vercelTriggerDefinitions: {
         };
         readonly type: "vercel.deployment.promoted";
     };
+    readonly vercelDeploymentRollback: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["deployment:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.deployment.rollback";
+    };
+    readonly vercelDeploymentIntegrationActionCancel: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["deployment:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.deployment.integrationActionCancel";
+    };
+    readonly vercelDeploymentIntegrationActionCleanup: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["deployment:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.deployment.integrationActionCleanup";
+    };
+    readonly vercelDeploymentIntegrationActionStart: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["deployment:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.deployment.integrationActionStart";
+    };
     readonly vercelDeploymentReady: {
         readonly account: {
             readonly connectionOptions: readonly [{
@@ -70,6 +130,147 @@ export declare const vercelTriggerDefinitions: {
         };
         readonly type: "vercel.deployment.succeeded";
     };
+    readonly vercelDomain: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["domain:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly name: "Vercel domain event";
+        readonly type: "vercel.domain";
+    };
+    readonly vercelDomainCreated: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["domain:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.domain.created";
+    };
+    readonly vercelDomainAutoRenewChanged: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["domain:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.domain.autoRenewChanged";
+    };
+    readonly vercelDomainCertificateAdd: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["domain:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.domain.certificateAdd";
+    };
+    readonly vercelDomainCertificateAddFailed: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["domain:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.domain.certificateAddFailed";
+    };
+    readonly vercelDomainCertificateDeleted: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["domain:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.domain.certificateDeleted";
+    };
+    readonly vercelDomainCertificateRenew: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["domain:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.domain.certificateRenew";
+    };
+    readonly vercelDomainCertificateRenewFailed: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["domain:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.domain.certificateRenewFailed";
+    };
+    readonly vercelDomainDnsRecordsChanged: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["domain:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.domain.dnsRecordsChanged";
+    };
+    readonly vercelDomainRenewal: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["domain:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.domain.renewal";
+    };
+    readonly vercelDomainRenewalFailed: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["domain:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.domain.renewalFailed";
+    };
+    readonly vercelDomainTransferInCompleted: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["domain:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.domain.transferInCompleted";
+    };
+    readonly vercelDomainTransferInFailed: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["domain:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.domain.transferInFailed";
+    };
+    readonly vercelDomainTransferInStarted: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["domain:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.domain.transferInStarted";
+    };
     readonly vercelIntegrationConfiguration: {
         readonly account: {
             readonly connectionOptions: readonly [{
@@ -123,6 +324,37 @@ export declare const vercelTriggerDefinitions: {
         };
         readonly type: "vercel.integration-configuration.transferred";
     };
+    readonly vercelIntegrationResource: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly name: "Vercel integration resource event";
+        readonly type: "vercel.integration-resource";
+    };
+    readonly vercelIntegrationResourceProjectConnected: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.integration-resource.projectConnected";
+    };
+    readonly vercelIntegrationResourceProjectDisconnected: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.integration-resource.projectDisconnected";
+    };
     readonly vercelProject: {
         readonly account: {
             readonly connectionOptions: readonly [{
@@ -276,4 +508,136 @@ export declare const vercelTriggerDefinitions: {
         };
         readonly type: "vercel.project.renamed";
     };
+    readonly vercelRollingRelease: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["deployment:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly name: "Vercel rolling release event";
+        readonly type: "vercel.rolling-release";
+    };
+    readonly vercelRollingReleaseApproved: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["deployment:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.rolling-release.approved";
+    };
+    readonly vercelRollingReleaseCompleted: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["deployment:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.rolling-release.completed";
+    };
+    readonly vercelRollingReleaseAborted: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["deployment:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.rolling-release.aborted";
+    };
+    readonly vercelRollingReleaseStarted: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly ["deployment:read"];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.rolling-release.started";
+    };
+    readonly vercelFeatureFlag: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly name: "Vercel feature flag event";
+        readonly type: "vercel.feature-flag";
+    };
+    readonly vercelFeatureFlagCreated: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.feature-flag.created";
+    };
+    readonly vercelFeatureFlagUpdated: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.feature-flag.updated";
+    };
+    readonly vercelFeatureFlagDeleted: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.feature-flag.deleted";
+    };
+    readonly vercelFeatureFlagSegmentCreated: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.feature-flag.segmentCreated";
+    };
+    readonly vercelFeatureFlagSegmentUpdated: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.feature-flag.segmentUpdated";
+    };
+    readonly vercelFeatureFlagSegmentDeleted: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.feature-flag.segmentDeleted";
+    };
+    readonly vercelAlertTriggered: {
+        readonly account: {
+            readonly connectionOptions: readonly [{
+                readonly connectionMethodId: "oauth";
+                readonly requiredScopes: readonly [];
+            }];
+            readonly serviceId: "vercel";
+        };
+        readonly type: "vercel.alert.triggered";
+    };
 };

package/dist/triggers/vercel.js

@@ -7,6 +7,24 @@ const VERCEL_DEPLOYMENT_ACCOUNT = {
     ],
     serviceId: "vercel",
 };
+const VERCEL_DOMAIN_ACCOUNT = {
+    connectionOptions: [
+        {
+            connectionMethodId: "oauth",
+            requiredScopes: ["domain:read"],
+        },
+    ],
+    serviceId: "vercel",
+};
+const VERCEL_OAUTH_ACCOUNT = {
+    connectionOptions: [
+        {
+            connectionMethodId: "oauth",
+            requiredScopes: [],
+        },
+    ],
+    serviceId: "vercel",
+};
 const VERCEL_INTEGRATION_CONFIGURATION_ACCOUNT = {
     connectionOptions: [
         {
@@ -49,6 +67,14 @@ export const vercelTriggerDefinitions = {
         name: "Vercel deployment event",
         type: "vercel.deployment",
     },
+    vercelDeploymentCheckRerequested: {
+        account: VERCEL_DEPLOYMENT_ACCOUNT,
+        type: "vercel.deployment.checkRerequested",
+    },
+    vercelDeploymentCleanup: {
+        account: VERCEL_DEPLOYMENT_ACCOUNT,
+        type: "vercel.deployment.cleanup",
+    },
     vercelDeploymentCanceled: {
         account: VERCEL_DEPLOYMENT_ACCOUNT,
         type: "vercel.deployment.canceled",
@@ -65,6 +91,22 @@ export const vercelTriggerDefinitions = {
         account: VERCEL_DEPLOYMENT_ACCOUNT,
         type: "vercel.deployment.promoted",
     },
+    vercelDeploymentRollback: {
+        account: VERCEL_DEPLOYMENT_ACCOUNT,
+        type: "vercel.deployment.rollback",
+    },
+    vercelDeploymentIntegrationActionCancel: {
+        account: VERCEL_DEPLOYMENT_ACCOUNT,
+        type: "vercel.deployment.integrationActionCancel",
+    },
+    vercelDeploymentIntegrationActionCleanup: {
+        account: VERCEL_DEPLOYMENT_ACCOUNT,
+        type: "vercel.deployment.integrationActionCleanup",
+    },
+    vercelDeploymentIntegrationActionStart: {
+        account: VERCEL_DEPLOYMENT_ACCOUNT,
+        type: "vercel.deployment.integrationActionStart",
+    },
     vercelDeploymentReady: {
         account: VERCEL_DEPLOYMENT_ACCOUNT,
         type: "vercel.deployment.ready",
@@ -73,6 +115,63 @@ export const vercelTriggerDefinitions = {
         account: VERCEL_DEPLOYMENT_ACCOUNT,
         type: "vercel.deployment.succeeded",
     },
+    vercelDomain: {
+        account: VERCEL_DOMAIN_ACCOUNT,
+        name: "Vercel domain event",
+        type: "vercel.domain",
+    },
+    vercelDomainCreated: {
+        account: VERCEL_DOMAIN_ACCOUNT,
+        type: "vercel.domain.created",
+    },
+    vercelDomainAutoRenewChanged: {
+        account: VERCEL_DOMAIN_ACCOUNT,
+        type: "vercel.domain.autoRenewChanged",
+    },
+    vercelDomainCertificateAdd: {
+        account: VERCEL_DOMAIN_ACCOUNT,
+        type: "vercel.domain.certificateAdd",
+    },
+    vercelDomainCertificateAddFailed: {
+        account: VERCEL_DOMAIN_ACCOUNT,
+        type: "vercel.domain.certificateAddFailed",
+    },
+    vercelDomainCertificateDeleted: {
+        account: VERCEL_DOMAIN_ACCOUNT,
+        type: "vercel.domain.certificateDeleted",
+    },
+    vercelDomainCertificateRenew: {
+        account: VERCEL_DOMAIN_ACCOUNT,
+        type: "vercel.domain.certificateRenew",
+    },
+    vercelDomainCertificateRenewFailed: {
+        account: VERCEL_DOMAIN_ACCOUNT,
+        type: "vercel.domain.certificateRenewFailed",
+    },
+    vercelDomainDnsRecordsChanged: {
+        account: VERCEL_DOMAIN_ACCOUNT,
+        type: "vercel.domain.dnsRecordsChanged",
+    },
+    vercelDomainRenewal: {
+        account: VERCEL_DOMAIN_ACCOUNT,
+        type: "vercel.domain.renewal",
+    },
+    vercelDomainRenewalFailed: {
+        account: VERCEL_DOMAIN_ACCOUNT,
+        type: "vercel.domain.renewalFailed",
+    },
+    vercelDomainTransferInCompleted: {
+        account: VERCEL_DOMAIN_ACCOUNT,
+        type: "vercel.domain.transferInCompleted",
+    },
+    vercelDomainTransferInFailed: {
+        account: VERCEL_DOMAIN_ACCOUNT,
+        type: "vercel.domain.transferInFailed",
+    },
+    vercelDomainTransferInStarted: {
+        account: VERCEL_DOMAIN_ACCOUNT,
+        type: "vercel.domain.transferInStarted",
+    },
     vercelIntegrationConfiguration: {
         account: VERCEL_INTEGRATION_CONFIGURATION_ACCOUNT,
         name: "Vercel integration configuration event",
@@ -96,6 +195,19 @@ export const vercelTriggerDefinitions = {
         account: VERCEL_INTEGRATION_CONFIGURATION_ACCOUNT,
         type: "vercel.integration-configuration.transferred",
     },
+    vercelIntegrationResource: {
+        account: VERCEL_OAUTH_ACCOUNT,
+        name: "Vercel integration resource event",
+        type: "vercel.integration-resource",
+    },
+    vercelIntegrationResourceProjectConnected: {
+        account: VERCEL_OAUTH_ACCOUNT,
+        type: "vercel.integration-resource.projectConnected",
+    },
+    vercelIntegrationResourceProjectDisconnected: {
+        account: VERCEL_OAUTH_ACCOUNT,
+        type: "vercel.integration-resource.projectDisconnected",
+    },
     vercelProject: {
         account: VERCEL_PROJECT_ACCOUNT,
         name: "Vercel project event",
@@ -159,4 +271,58 @@ export const vercelTriggerDefinitions = {
         account: VERCEL_PROJECT_ACCOUNT,
         type: "vercel.project.renamed",
     },
+    vercelRollingRelease: {
+        account: VERCEL_DEPLOYMENT_ACCOUNT,
+        name: "Vercel rolling release event",
+        type: "vercel.rolling-release",
+    },
+    vercelRollingReleaseApproved: {
+        account: VERCEL_DEPLOYMENT_ACCOUNT,
+        type: "vercel.rolling-release.approved",
+    },
+    vercelRollingReleaseCompleted: {
+        account: VERCEL_DEPLOYMENT_ACCOUNT,
+        type: "vercel.rolling-release.completed",
+    },
+    vercelRollingReleaseAborted: {
+        account: VERCEL_DEPLOYMENT_ACCOUNT,
+        type: "vercel.rolling-release.aborted",
+    },
+    vercelRollingReleaseStarted: {
+        account: VERCEL_DEPLOYMENT_ACCOUNT,
+        type: "vercel.rolling-release.started",
+    },
+    vercelFeatureFlag: {
+        account: VERCEL_OAUTH_ACCOUNT,
+        name: "Vercel feature flag event",
+        type: "vercel.feature-flag",
+    },
+    vercelFeatureFlagCreated: {
+        account: VERCEL_OAUTH_ACCOUNT,
+        type: "vercel.feature-flag.created",
+    },
+    vercelFeatureFlagUpdated: {
+        account: VERCEL_OAUTH_ACCOUNT,
+        type: "vercel.feature-flag.updated",
+    },
+    vercelFeatureFlagDeleted: {
+        account: VERCEL_OAUTH_ACCOUNT,
+        type: "vercel.feature-flag.deleted",
+    },
+    vercelFeatureFlagSegmentCreated: {
+        account: VERCEL_OAUTH_ACCOUNT,
+        type: "vercel.feature-flag.segmentCreated",
+    },
+    vercelFeatureFlagSegmentUpdated: {
+        account: VERCEL_OAUTH_ACCOUNT,
+        type: "vercel.feature-flag.segmentUpdated",
+    },
+    vercelFeatureFlagSegmentDeleted: {
+        account: VERCEL_OAUTH_ACCOUNT,
+        type: "vercel.feature-flag.segmentDeleted",
+    },
+    vercelAlertTriggered: {
+        account: VERCEL_OAUTH_ACCOUNT,
+        type: "vercel.alert.triggered",
+    },
 };

package/dist/types.d.ts

@@ -87,9 +87,14 @@ export interface IntegrationAccountRequirement<TServiceId extends string = strin
     connectionOptions: readonly IntegrationAccountConnectionOption[];
     serviceId: TServiceId;
 }
+/** Account-selection behavior for one public trigger type. */
+export interface TriggerAccountRequirement<TServiceId extends string = string> extends IntegrationAccountRequirement<TServiceId> {
+    /** Whether omission plans the project's default binding. Defaults to true. */
+    planDefaultBinding?: boolean;
+}
 /** Runtime-neutral metadata for one public trigger type. */
 export interface TriggerDefinition<TType extends string = string, TServiceId extends string = string> {
-    account?: IntegrationAccountRequirement<TServiceId>;
+    account?: TriggerAccountRequirement<TServiceId>;
     description?: string;
     /** Adds labeled secondary details to this trigger's presentation. */
     getDetails?(context: TriggerPresentationContext): TriggerPresentationDetail[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automate.ax/catalog",
-  "version": "0.111.1",
+  "version": "0.112.4",
   "description": "Shared integration service and trigger definitions for Automate.ax.",
   "license": "MIT",
   "repository": {

package/src/authoring.ts

@@ -4,5 +4,6 @@ export {
   type IntegrationAccountRequirement,
   type IntegrationScopeRequirement,
   type ScopeRequirementGroup,
+  type TriggerAccountRequirement,
   type TriggerDefinition,
 } from "./types"

package/src/index.ts

@@ -60,6 +60,7 @@ export {
   type IntegrationScopeRequirement,
   type IntegrationServiceDefinition,
   type ScopeRequirementGroup,
+  type TriggerAccountRequirement,
   type TriggerDefinition,
   type TriggerPresentation,
   type TriggerPresentationContext,

package/src/triggers/automate.ts

@@ -1,4 +1,4 @@
-import type { IntegrationAccountRequirement, TriggerDefinition } from "../types"
+import type { TriggerAccountRequirement, TriggerDefinition } from "../types"
 import * as z from "zod/mini"
 
 const AUTOMATE_PROJECT_READ_ACCOUNT = {
@@ -8,8 +8,9 @@ const AUTOMATE_PROJECT_READ_ACCOUNT = {
       requiredScopes: ["project:read"],
     },
   ],
+  planDefaultBinding: false,
   serviceId: "automate",
-} as const satisfies IntegrationAccountRequirement
+} as const satisfies TriggerAccountRequirement
 
 const AUTOMATE_DEPLOYMENT_READ_ACCOUNT = {
   connectionOptions: [
@@ -18,8 +19,9 @@ const AUTOMATE_DEPLOYMENT_READ_ACCOUNT = {
       requiredScopes: ["deployment:read"],
     },
   ],
+  planDefaultBinding: false,
   serviceId: "automate",
-} as const satisfies IntegrationAccountRequirement
+} as const satisfies TriggerAccountRequirement
 
 const AUTOMATION_CONFIG_SCHEMA = z.object({ automationId: z.string() })
 const DEPLOYMENT_CONFIG_SCHEMA = z.object({ projectId: z.string() })