@trigger.dev/platform 1.0.29 → 1.2.0

package/dist/index.cjs

@@ -23,8 +23,20 @@ __export(v3_exports, {
   AddOn: () => AddOn,
   AddOnDefinition: () => AddOnDefinition,
   AddOns: () => AddOns,
+  ApplyPromoCodeBodySchema: () => ApplyPromoCodeBodySchema,
+  ApplyPromoCodeResult: () => ApplyPromoCodeResult,
   BillingAlertsResult: () => BillingAlertsResult,
   BillingClient: () => BillingClient,
+  BillingLimitActiveOrg: () => BillingLimitActiveOrg,
+  BillingLimitConfiguredCustom: () => BillingLimitConfiguredCustom,
+  BillingLimitConfiguredNone: () => BillingLimitConfiguredNone,
+  BillingLimitConfiguredPlan: () => BillingLimitConfiguredPlan,
+  BillingLimitPendingResolveOrg: () => BillingLimitPendingResolveOrg,
+  BillingLimitResult: () => BillingLimitResult,
+  BillingLimitState: () => BillingLimitState,
+  BillingLimitUnconfigured: () => BillingLimitUnconfigured,
+  BillingLimitsActiveResult: () => BillingLimitsActiveResult,
+  BillingLimitsPendingResolvesResult: () => BillingLimitsPendingResolvesResult,
   CreatePrivateLinkConnectionBody: () => CreatePrivateLinkConnectionBody,
   CurrentPlan: () => CurrentPlan,
   CustomerPortalRequestBodySchema: () => CustomerPortalRequestBodySchema,
@@ -35,6 +47,7 @@ __export(v3_exports, {
   ErrorSchema: () => ErrorSchema,
   FreeConnectRequiredSchema: () => FreeConnectRequiredSchema,
   FreeConnectedSchema: () => FreeConnectedSchema,
+  MAX_INVOCATION_COST_IN_CENTS: () => MAX_INVOCATION_COST_IN_CENTS,
   PlanDefinitionSchema: () => PlanDefinitionSchema,
   Plans: () => Plans,
   PlansResult: () => PlansResult,
@@ -42,12 +55,14 @@ __export(v3_exports, {
   PrivateLinkConnectionList: () => PrivateLinkConnectionList,
   PrivateLinkConnectionStatus: () => PrivateLinkConnectionStatus,
   PrivateLinkRegionsResult: () => PrivateLinkRegionsResult,
+  PromoCreditsResult: () => PromoCreditsResult,
   RegistryCredentialsResponseSchema: () => RegistryCredentialsResponseSchema,
   ReportComputeUsageEvent: () => ReportComputeUsageEvent,
   ReportInvocationUsageEvent: () => ReportInvocationUsageEvent,
   ReportInvocationUsageResult: () => ReportInvocationUsageResult,
   ReportUsagePlan: () => ReportUsagePlan,
   ReportUsageResult: () => ReportUsageResult,
+  ResolveBillingLimitRequest: () => ResolveBillingLimitRequest,
   SetAddOnBody: () => SetAddOnBody,
   SetAddOnResult: () => SetAddOnResult,
   SetPlanBodySchema: () => SetPlanBodySchema,
@@ -56,10 +71,13 @@ __export(v3_exports, {
   TriggerInitialDeploymentRequestSchema: () => TriggerInitialDeploymentRequestSchema,
   TriggerInitialDeploymentResponseSchema: () => TriggerInitialDeploymentResponseSchema,
   UpdateBillingAlertsRequest: () => UpdateBillingAlertsRequest,
+  UpdateBillingLimitRequest: () => UpdateBillingLimitRequest,
   UsageParams: () => UsageParams,
   UsageResult: () => UsageResult,
   UsageSeriesParams: () => UsageSeriesParams,
   UsageSeriesResult: () => UsageSeriesResult,
+  ValidatePromoCodeBodySchema: () => ValidatePromoCodeBodySchema,
+  ValidatePromoCodeResult: () => ValidatePromoCodeResult,
   defaultMachine: () => defaultMachine,
   machineDefinition: () => machineDefinition,
   machines: () => machines,
@@ -357,12 +375,15 @@ var ReportUsageResult = import_zod6.z.object({
   balance: import_zod6.z.number().optional(),
   usage: import_zod6.z.number().optional(),
   overage: import_zod6.z.number().optional(),
-  plan: ReportUsagePlan.optional()
+  plan: ReportUsagePlan.optional(),
+  limitState: import_zod6.z.literal("grace").optional(),
+  reason: import_zod6.z.enum(["free_tier_exceeded", "billing_limit"]).optional()
 });
+var MAX_INVOCATION_COST_IN_CENTS = 1e4;
 var ReportInvocationUsageEvent = import_zod6.z.object({
-  organizationId: import_zod6.z.string(),
-  costInCents: import_zod6.z.number(),
-  additionalData: import_zod6.z.record(import_zod6.z.any()).optional()
+  organizationId: import_zod6.z.string().min(1).max(128),
+  costInCents: import_zod6.z.number().finite().min(0).max(MAX_INVOCATION_COST_IN_CENTS),
+  additionalData: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.any()).optional()
 });
 var ReportInvocationUsageResult = import_zod6.z.discriminatedUnion("success", [
   import_zod6.z.object({
@@ -383,76 +404,165 @@ var BillingAlertDefinition = import_zod7.z.object({
 });
 var BillingAlertsResult = BillingAlertDefinition;
 var UpdateBillingAlertsRequest = import_zod7.z.object({
-  amount: import_zod7.z.number(),
+  amount: import_zod7.z.number().positive(),
   emails: import_zod7.z.array(import_zod7.z.string()),
   alertLevels: import_zod7.z.array(import_zod7.z.number())
 });
 
-// src/v3/schemas/registryCredentials.ts
+// src/v3/schemas/billingLimit.ts
 var import_zod8 = require("zod");
-var RegistryCredentialsResponseSchema = import_zod8.z.object({
-  username: import_zod8.z.string(),
-  password: import_zod8.z.string(),
-  expiresAt: import_zod8.z.string().datetime(),
-  repositoryUri: import_zod8.z.string()
+var BillingLimitState = import_zod8.z.discriminatedUnion("status", [
+  import_zod8.z.object({
+    status: import_zod8.z.literal("ok")
+  }),
+  import_zod8.z.object({
+    status: import_zod8.z.literal("grace"),
+    hitAt: import_zod8.z.string(),
+    graceEndsAt: import_zod8.z.string()
+  }),
+  import_zod8.z.object({
+    status: import_zod8.z.literal("rejected"),
+    hitAt: import_zod8.z.string(),
+    graceEndsAt: import_zod8.z.string()
+  })
+]);
+var billingLimitConfiguredFields = {
+  isConfigured: import_zod8.z.literal(true),
+  cancelInProgressRuns: import_zod8.z.boolean(),
+  limitState: BillingLimitState,
+  effectiveAmountCents: import_zod8.z.number().int().nonnegative().nullable(),
+  gracePeriodMs: import_zod8.z.number().int().nonnegative()
+};
+var BillingLimitUnconfigured = import_zod8.z.object({
+  isConfigured: import_zod8.z.literal(false),
+  gracePeriodMs: import_zod8.z.number().int().nonnegative()
+});
+var BillingLimitConfiguredNone = import_zod8.z.object({
+  ...billingLimitConfiguredFields,
+  mode: import_zod8.z.literal("none")
+});
+var BillingLimitConfiguredPlan = import_zod8.z.object({
+  ...billingLimitConfiguredFields,
+  mode: import_zod8.z.literal("plan")
+});
+var BillingLimitConfiguredCustom = import_zod8.z.object({
+  ...billingLimitConfiguredFields,
+  mode: import_zod8.z.literal("custom"),
+  amountCents: import_zod8.z.number().int().positive()
+});
+var BillingLimitResult = import_zod8.z.union([
+  BillingLimitUnconfigured,
+  BillingLimitConfiguredNone,
+  BillingLimitConfiguredPlan,
+  BillingLimitConfiguredCustom
+]);
+var UpdateBillingLimitRequest = import_zod8.z.discriminatedUnion("mode", [
+  import_zod8.z.object({
+    mode: import_zod8.z.literal("none"),
+    cancelInProgressRuns: import_zod8.z.boolean()
+  }),
+  import_zod8.z.object({
+    mode: import_zod8.z.literal("plan"),
+    cancelInProgressRuns: import_zod8.z.boolean()
+  }),
+  import_zod8.z.object({
+    mode: import_zod8.z.literal("custom"),
+    amountCents: import_zod8.z.number().int().positive(),
+    cancelInProgressRuns: import_zod8.z.boolean()
+  })
+]);
+var ResolveBillingLimitRequest = import_zod8.z.discriminatedUnion("action", [
+  import_zod8.z.object({
+    action: import_zod8.z.literal("increase"),
+    newAmountCents: import_zod8.z.number().int().positive(),
+    resumeMode: import_zod8.z.enum(["queue", "new_only"])
+  }),
+  import_zod8.z.object({
+    action: import_zod8.z.literal("remove"),
+    resumeMode: import_zod8.z.enum(["queue", "new_only"])
+  })
+]);
+var BillingLimitActiveOrg = import_zod8.z.object({
+  orgId: import_zod8.z.string(),
+  limitState: import_zod8.z.enum(["grace", "rejected"])
+});
+var BillingLimitsActiveResult = import_zod8.z.object({
+  orgs: import_zod8.z.array(BillingLimitActiveOrg)
+});
+var BillingLimitPendingResolveOrg = import_zod8.z.object({
+  organizationId: import_zod8.z.string(),
+  resumeMode: import_zod8.z.enum(["queue", "new_only"]),
+  resolvedAt: import_zod8.z.string()
+});
+var BillingLimitsPendingResolvesResult = import_zod8.z.object({
+  orgs: import_zod8.z.array(BillingLimitPendingResolveOrg)
 });
 
-// src/v3/schemas/enqueueBuild.ts
+// src/v3/schemas/registryCredentials.ts
 var import_zod9 = require("zod");
-var EnqueueBuildRequestSchema = import_zod9.z.object({
-  deploymentId: import_zod9.z.string(),
-  artifactKey: import_zod9.z.string(),
-  options: import_zod9.z.object({
-    skipPromotion: import_zod9.z.boolean().optional(),
-    configFilePath: import_zod9.z.string().optional()
+var RegistryCredentialsResponseSchema = import_zod9.z.object({
+  username: import_zod9.z.string(),
+  password: import_zod9.z.string(),
+  expiresAt: import_zod9.z.string().datetime(),
+  repositoryUri: import_zod9.z.string()
+});
+
+// src/v3/schemas/enqueueBuild.ts
+var import_zod10 = require("zod");
+var EnqueueBuildRequestSchema = import_zod10.z.object({
+  deploymentId: import_zod10.z.string(),
+  artifactKey: import_zod10.z.string(),
+  options: import_zod10.z.object({
+    skipPromotion: import_zod10.z.boolean().optional(),
+    configFilePath: import_zod10.z.string().optional()
   })
 });
-var EnqueueBuildResponseSchema = import_zod9.z.object({
-  buildId: import_zod9.z.string()
+var EnqueueBuildResponseSchema = import_zod10.z.object({
+  buildId: import_zod10.z.string()
 });
 
 // src/v3/schemas/initialDeployment.ts
-var import_zod10 = require("zod");
-var TriggerInitialDeploymentRequestSchema = import_zod10.z.object({
-  environment: import_zod10.z.enum(["prod", "staging", "preview"])
+var import_zod11 = require("zod");
+var TriggerInitialDeploymentRequestSchema = import_zod11.z.object({
+  environment: import_zod11.z.enum(["prod", "staging", "preview"])
 });
-var TriggerInitialDeploymentResponseSchema = import_zod10.z.object({
-  ok: import_zod10.z.boolean()
+var TriggerInitialDeploymentResponseSchema = import_zod11.z.object({
+  ok: import_zod11.z.boolean()
 });
 
 // src/v3/schemas/privateLink.ts
-var import_zod11 = require("zod");
-var PrivateLinkConnectionStatus = import_zod11.z.enum([
+var import_zod12 = require("zod");
+var PrivateLinkConnectionStatus = import_zod12.z.enum([
   "PENDING",
   "PROVISIONING",
   "ACTIVE",
   "ERROR",
   "DELETING"
 ]);
-var PrivateLinkConnection = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  friendlyId: import_zod11.z.string(),
-  name: import_zod11.z.string(),
-  organizationId: import_zod11.z.string(),
-  endpointServiceName: import_zod11.z.string(),
-  targetRegion: import_zod11.z.string(),
+var PrivateLinkConnection = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  friendlyId: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  organizationId: import_zod12.z.string(),
+  endpointServiceName: import_zod12.z.string(),
+  targetRegion: import_zod12.z.string(),
   status: PrivateLinkConnectionStatus,
-  statusMessage: import_zod11.z.string().nullable(),
-  endpointDnsName: import_zod11.z.string().nullable(),
-  endpointIps: import_zod11.z.array(import_zod11.z.string()).nullable(),
-  provisionedAt: import_zod11.z.string().nullable(),
-  createdAt: import_zod11.z.string(),
-  updatedAt: import_zod11.z.string()
-});
-var PrivateLinkConnectionList = import_zod11.z.object({
-  connections: import_zod11.z.array(PrivateLinkConnection)
-});
-var CreatePrivateLinkConnectionBody = import_zod11.z.object({
-  name: import_zod11.z.string().min(1).max(100).regex(
+  statusMessage: import_zod12.z.string().nullable(),
+  endpointDnsName: import_zod12.z.string().nullable(),
+  endpointIps: import_zod12.z.array(import_zod12.z.string()).nullable(),
+  provisionedAt: import_zod12.z.string().nullable(),
+  createdAt: import_zod12.z.string(),
+  updatedAt: import_zod12.z.string()
+});
+var PrivateLinkConnectionList = import_zod12.z.object({
+  connections: import_zod12.z.array(PrivateLinkConnection)
+});
+var CreatePrivateLinkConnectionBody = import_zod12.z.object({
+  name: import_zod12.z.string().min(1).max(100).regex(
     /^[a-zA-Z][a-zA-Z0-9 _-]*$/,
     "Must start with a letter and contain only letters, numbers, spaces, hyphens, or underscores"
   ),
-  endpointServiceName: import_zod11.z.string().regex(
+  endpointServiceName: import_zod12.z.string().regex(
     /^com\.amazonaws\.vpce\..+\.vpce-svc-.+$/,
     "Must be a valid VPC Endpoint Service name (com.amazonaws.vpce.<region>.vpce-svc-*)"
   ),
@@ -460,14 +570,43 @@ var CreatePrivateLinkConnectionBody = import_zod11.z.object({
   // this validates the AWS region *format* only; the authoritative check that
   // the region is actually configured happens server-side against the set of
   // regions discovered from env vars.
-  targetRegion: import_zod11.z.string().regex(/^[a-z]{2}-[a-z]+-\d+$/, "Must be a valid AWS region")
+  targetRegion: import_zod12.z.string().regex(/^[a-z]{2}-[a-z]+-\d+$/, "Must be a valid AWS region")
+});
+var DeletePrivateLinkResult = import_zod12.z.object({
+  success: import_zod12.z.boolean()
+});
+var PrivateLinkRegionsResult = import_zod12.z.object({
+  availableRegions: import_zod12.z.array(import_zod12.z.string()),
+  activeRegions: import_zod12.z.array(import_zod12.z.string())
+});
+
+// src/v3/schemas/promoCodes.ts
+var import_zod13 = require("zod");
+var ValidatePromoCodeBodySchema = import_zod13.z.object({
+  code: import_zod13.z.string()
+});
+var ValidatePromoCodeResult = import_zod13.z.object({
+  valid: import_zod13.z.boolean(),
+  amountInCents: import_zod13.z.number().optional(),
+  expiresAt: import_zod13.z.string().datetime().nullable().optional()
+});
+var ApplyPromoCodeBodySchema = import_zod13.z.object({
+  code: import_zod13.z.string(),
+  userId: import_zod13.z.string()
 });
-var DeletePrivateLinkResult = import_zod11.z.object({
-  success: import_zod11.z.boolean()
+var ApplyPromoCodeResult = import_zod13.z.object({
+  applied: import_zod13.z.boolean(),
+  amountInCents: import_zod13.z.number().optional(),
+  expiresAt: import_zod13.z.string().datetime().nullable().optional(),
+  // Present when applied is false, e.g. "already_redeemed" or "invalid".
+  reason: import_zod13.z.string().optional()
 });
-var PrivateLinkRegionsResult = import_zod11.z.object({
-  availableRegions: import_zod11.z.array(import_zod11.z.string()),
-  activeRegions: import_zod11.z.array(import_zod11.z.string())
+var PromoCreditsResult = import_zod13.z.object({
+  promoCredits: import_zod13.z.object({
+    grantedCents: import_zod13.z.number(),
+    remainingCents: import_zod13.z.number(),
+    expiresAt: import_zod13.z.string().datetime().nullable()
+  }).nullable()
 });
 
 // src/v3/client/index.ts
@@ -521,6 +660,34 @@ var BillingClient = class {
       }
     );
   }
+  async validatePromoCode(code) {
+    return await this.fetch(`/api/v1/promo-codes/validate`, ValidatePromoCodeResult, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ code })
+    });
+  }
+  async applyPromoCode(orgId, body) {
+    return await this.fetch(
+      `/api/v1/orgs/${orgId}/promo/apply`,
+      ApplyPromoCodeResult,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      }
+    );
+  }
+  async promoCredits(orgId) {
+    return await this.fetch(
+      `/api/v1/orgs/${orgId}/promo/credits`,
+      PromoCreditsResult
+    );
+  }
   async createPortalSession(orgId, body) {
     return await this.fetch(
       `/api/v1/orgs/${orgId}/v3/subscription/portal`,
@@ -622,6 +789,41 @@ var BillingClient = class {
       }
     );
   }
+  async getBillingLimit(orgId) {
+    return await this.fetch(
+      `/api/v1/orgs/${orgId}/billing-limit`,
+      BillingLimitResult
+    );
+  }
+  async updateBillingLimit(orgId, body) {
+    return await this.fetch(
+      `/api/v1/orgs/${orgId}/billing-limit`,
+      BillingLimitResult,
+      {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      }
+    );
+  }
+  async resolveBillingLimit(orgId, body) {
+    return await this.fetch(
+      `/api/v1/orgs/${orgId}/billing-limit/resolve`,
+      BillingLimitResult,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      }
+    );
+  }
+  async getActiveBillingLimits() {
+    return await this.fetch(`/api/v1/billing-limits/active`, BillingLimitsActiveResult);
+  }
   async getPrivateLinks(orgId) {
     return await this.fetch(
       `/api/v1/orgs/${orgId}/private-connections`,
@@ -806,8 +1008,20 @@ var defaultMachine = "small-1x";
   AddOn,
   AddOnDefinition,
   AddOns,
+  ApplyPromoCodeBodySchema,
+  ApplyPromoCodeResult,
   BillingAlertsResult,
   BillingClient,
+  BillingLimitActiveOrg,
+  BillingLimitConfiguredCustom,
+  BillingLimitConfiguredNone,
+  BillingLimitConfiguredPlan,
+  BillingLimitPendingResolveOrg,
+  BillingLimitResult,
+  BillingLimitState,
+  BillingLimitUnconfigured,
+  BillingLimitsActiveResult,
+  BillingLimitsPendingResolvesResult,
   CreatePrivateLinkConnectionBody,
   CurrentPlan,
   CustomerPortalRequestBodySchema,
@@ -818,6 +1032,7 @@ var defaultMachine = "small-1x";
   ErrorSchema,
   FreeConnectRequiredSchema,
   FreeConnectedSchema,
+  MAX_INVOCATION_COST_IN_CENTS,
   PlanDefinitionSchema,
   Plans,
   PlansResult,
@@ -825,12 +1040,14 @@ var defaultMachine = "small-1x";
   PrivateLinkConnectionList,
   PrivateLinkConnectionStatus,
   PrivateLinkRegionsResult,
+  PromoCreditsResult,
   RegistryCredentialsResponseSchema,
   ReportComputeUsageEvent,
   ReportInvocationUsageEvent,
   ReportInvocationUsageResult,
   ReportUsagePlan,
   ReportUsageResult,
+  ResolveBillingLimitRequest,
   SetAddOnBody,
   SetAddOnResult,
   SetPlanBodySchema,
@@ -839,10 +1056,13 @@ var defaultMachine = "small-1x";
   TriggerInitialDeploymentRequestSchema,
   TriggerInitialDeploymentResponseSchema,
   UpdateBillingAlertsRequest,
+  UpdateBillingLimitRequest,
   UsageParams,
   UsageResult,
   UsageSeriesParams,
   UsageSeriesResult,
+  ValidatePromoCodeBodySchema,
+  ValidatePromoCodeResult,
   defaultMachine,
   machineDefinition,
   machines,