@trigger.dev/platform 1.1.0 → 1.2.0

package/dist/index.js

@@ -288,11 +288,14 @@ var ReportUsageResult = z6.object({
   balance: z6.number().optional(),
   usage: z6.number().optional(),
   overage: z6.number().optional(),
-  plan: ReportUsagePlan.optional()
+  plan: ReportUsagePlan.optional(),
+  limitState: z6.literal("grace").optional(),
+  reason: z6.enum(["free_tier_exceeded", "billing_limit"]).optional()
 });
+var MAX_INVOCATION_COST_IN_CENTS = 1e4;
 var ReportInvocationUsageEvent = z6.object({
-  organizationId: z6.string(),
-  costInCents: z6.number(),
+  organizationId: z6.string().min(1).max(128),
+  costInCents: z6.number().finite().min(0).max(MAX_INVOCATION_COST_IN_CENTS),
   additionalData: z6.record(z6.string(), z6.any()).optional()
 });
 var ReportInvocationUsageResult = z6.discriminatedUnion("success", [
@@ -314,76 +317,165 @@ var BillingAlertDefinition = z7.object({
 });
 var BillingAlertsResult = BillingAlertDefinition;
 var UpdateBillingAlertsRequest = z7.object({
-  amount: z7.number(),
+  amount: z7.number().positive(),
   emails: z7.array(z7.string()),
   alertLevels: z7.array(z7.number())
 });
 
-// src/v3/schemas/registryCredentials.ts
+// src/v3/schemas/billingLimit.ts
 import { z as z8 } from "zod";
-var RegistryCredentialsResponseSchema = z8.object({
-  username: z8.string(),
-  password: z8.string(),
-  expiresAt: z8.string().datetime(),
-  repositoryUri: z8.string()
+var BillingLimitState = z8.discriminatedUnion("status", [
+  z8.object({
+    status: z8.literal("ok")
+  }),
+  z8.object({
+    status: z8.literal("grace"),
+    hitAt: z8.string(),
+    graceEndsAt: z8.string()
+  }),
+  z8.object({
+    status: z8.literal("rejected"),
+    hitAt: z8.string(),
+    graceEndsAt: z8.string()
+  })
+]);
+var billingLimitConfiguredFields = {
+  isConfigured: z8.literal(true),
+  cancelInProgressRuns: z8.boolean(),
+  limitState: BillingLimitState,
+  effectiveAmountCents: z8.number().int().nonnegative().nullable(),
+  gracePeriodMs: z8.number().int().nonnegative()
+};
+var BillingLimitUnconfigured = z8.object({
+  isConfigured: z8.literal(false),
+  gracePeriodMs: z8.number().int().nonnegative()
+});
+var BillingLimitConfiguredNone = z8.object({
+  ...billingLimitConfiguredFields,
+  mode: z8.literal("none")
+});
+var BillingLimitConfiguredPlan = z8.object({
+  ...billingLimitConfiguredFields,
+  mode: z8.literal("plan")
+});
+var BillingLimitConfiguredCustom = z8.object({
+  ...billingLimitConfiguredFields,
+  mode: z8.literal("custom"),
+  amountCents: z8.number().int().positive()
+});
+var BillingLimitResult = z8.union([
+  BillingLimitUnconfigured,
+  BillingLimitConfiguredNone,
+  BillingLimitConfiguredPlan,
+  BillingLimitConfiguredCustom
+]);
+var UpdateBillingLimitRequest = z8.discriminatedUnion("mode", [
+  z8.object({
+    mode: z8.literal("none"),
+    cancelInProgressRuns: z8.boolean()
+  }),
+  z8.object({
+    mode: z8.literal("plan"),
+    cancelInProgressRuns: z8.boolean()
+  }),
+  z8.object({
+    mode: z8.literal("custom"),
+    amountCents: z8.number().int().positive(),
+    cancelInProgressRuns: z8.boolean()
+  })
+]);
+var ResolveBillingLimitRequest = z8.discriminatedUnion("action", [
+  z8.object({
+    action: z8.literal("increase"),
+    newAmountCents: z8.number().int().positive(),
+    resumeMode: z8.enum(["queue", "new_only"])
+  }),
+  z8.object({
+    action: z8.literal("remove"),
+    resumeMode: z8.enum(["queue", "new_only"])
+  })
+]);
+var BillingLimitActiveOrg = z8.object({
+  orgId: z8.string(),
+  limitState: z8.enum(["grace", "rejected"])
+});
+var BillingLimitsActiveResult = z8.object({
+  orgs: z8.array(BillingLimitActiveOrg)
+});
+var BillingLimitPendingResolveOrg = z8.object({
+  organizationId: z8.string(),
+  resumeMode: z8.enum(["queue", "new_only"]),
+  resolvedAt: z8.string()
+});
+var BillingLimitsPendingResolvesResult = z8.object({
+  orgs: z8.array(BillingLimitPendingResolveOrg)
 });
 
-// src/v3/schemas/enqueueBuild.ts
+// src/v3/schemas/registryCredentials.ts
 import { z as z9 } from "zod";
-var EnqueueBuildRequestSchema = z9.object({
-  deploymentId: z9.string(),
-  artifactKey: z9.string(),
-  options: z9.object({
-    skipPromotion: z9.boolean().optional(),
-    configFilePath: z9.string().optional()
+var RegistryCredentialsResponseSchema = z9.object({
+  username: z9.string(),
+  password: z9.string(),
+  expiresAt: z9.string().datetime(),
+  repositoryUri: z9.string()
+});
+
+// src/v3/schemas/enqueueBuild.ts
+import { z as z10 } from "zod";
+var EnqueueBuildRequestSchema = z10.object({
+  deploymentId: z10.string(),
+  artifactKey: z10.string(),
+  options: z10.object({
+    skipPromotion: z10.boolean().optional(),
+    configFilePath: z10.string().optional()
   })
 });
-var EnqueueBuildResponseSchema = z9.object({
-  buildId: z9.string()
+var EnqueueBuildResponseSchema = z10.object({
+  buildId: z10.string()
 });
 
 // src/v3/schemas/initialDeployment.ts
-import { z as z10 } from "zod";
-var TriggerInitialDeploymentRequestSchema = z10.object({
-  environment: z10.enum(["prod", "staging", "preview"])
+import { z as z11 } from "zod";
+var TriggerInitialDeploymentRequestSchema = z11.object({
+  environment: z11.enum(["prod", "staging", "preview"])
 });
-var TriggerInitialDeploymentResponseSchema = z10.object({
-  ok: z10.boolean()
+var TriggerInitialDeploymentResponseSchema = z11.object({
+  ok: z11.boolean()
 });
 
 // src/v3/schemas/privateLink.ts
-import { z as z11 } from "zod";
-var PrivateLinkConnectionStatus = z11.enum([
+import { z as z12 } from "zod";
+var PrivateLinkConnectionStatus = z12.enum([
   "PENDING",
   "PROVISIONING",
   "ACTIVE",
   "ERROR",
   "DELETING"
 ]);
-var PrivateLinkConnection = z11.object({
-  id: z11.string(),
-  friendlyId: z11.string(),
-  name: z11.string(),
-  organizationId: z11.string(),
-  endpointServiceName: z11.string(),
-  targetRegion: z11.string(),
+var PrivateLinkConnection = z12.object({
+  id: z12.string(),
+  friendlyId: z12.string(),
+  name: z12.string(),
+  organizationId: z12.string(),
+  endpointServiceName: z12.string(),
+  targetRegion: z12.string(),
   status: PrivateLinkConnectionStatus,
-  statusMessage: z11.string().nullable(),
-  endpointDnsName: z11.string().nullable(),
-  endpointIps: z11.array(z11.string()).nullable(),
-  provisionedAt: z11.string().nullable(),
-  createdAt: z11.string(),
-  updatedAt: z11.string()
-});
-var PrivateLinkConnectionList = z11.object({
-  connections: z11.array(PrivateLinkConnection)
-});
-var CreatePrivateLinkConnectionBody = z11.object({
-  name: z11.string().min(1).max(100).regex(
+  statusMessage: z12.string().nullable(),
+  endpointDnsName: z12.string().nullable(),
+  endpointIps: z12.array(z12.string()).nullable(),
+  provisionedAt: z12.string().nullable(),
+  createdAt: z12.string(),
+  updatedAt: z12.string()
+});
+var PrivateLinkConnectionList = z12.object({
+  connections: z12.array(PrivateLinkConnection)
+});
+var CreatePrivateLinkConnectionBody = z12.object({
+  name: z12.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: z11.string().regex(
+  endpointServiceName: z12.string().regex(
     /^com\.amazonaws\.vpce\..+\.vpce-svc-.+$/,
     "Must be a valid VPC Endpoint Service name (com.amazonaws.vpce.<region>.vpce-svc-*)"
   ),
@@ -391,14 +483,43 @@ var CreatePrivateLinkConnectionBody = z11.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: z11.string().regex(/^[a-z]{2}-[a-z]+-\d+$/, "Must be a valid AWS region")
+  targetRegion: z12.string().regex(/^[a-z]{2}-[a-z]+-\d+$/, "Must be a valid AWS region")
+});
+var DeletePrivateLinkResult = z12.object({
+  success: z12.boolean()
 });
-var DeletePrivateLinkResult = z11.object({
-  success: z11.boolean()
+var PrivateLinkRegionsResult = z12.object({
+  availableRegions: z12.array(z12.string()),
+  activeRegions: z12.array(z12.string())
 });
-var PrivateLinkRegionsResult = z11.object({
-  availableRegions: z11.array(z11.string()),
-  activeRegions: z11.array(z11.string())
+
+// src/v3/schemas/promoCodes.ts
+import { z as z13 } from "zod";
+var ValidatePromoCodeBodySchema = z13.object({
+  code: z13.string()
+});
+var ValidatePromoCodeResult = z13.object({
+  valid: z13.boolean(),
+  amountInCents: z13.number().optional(),
+  expiresAt: z13.string().datetime().nullable().optional()
+});
+var ApplyPromoCodeBodySchema = z13.object({
+  code: z13.string(),
+  userId: z13.string()
+});
+var ApplyPromoCodeResult = z13.object({
+  applied: z13.boolean(),
+  amountInCents: z13.number().optional(),
+  expiresAt: z13.string().datetime().nullable().optional(),
+  // Present when applied is false, e.g. "already_redeemed" or "invalid".
+  reason: z13.string().optional()
+});
+var PromoCreditsResult = z13.object({
+  promoCredits: z13.object({
+    grantedCents: z13.number(),
+    remainingCents: z13.number(),
+    expiresAt: z13.string().datetime().nullable()
+  }).nullable()
 });
 
 // src/v3/client/index.ts
@@ -452,6 +573,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`,
@@ -553,6 +702,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`,
@@ -736,8 +920,20 @@ export {
   AddOn,
   AddOnDefinition,
   AddOns,
+  ApplyPromoCodeBodySchema,
+  ApplyPromoCodeResult,
   BillingAlertsResult,
   BillingClient,
+  BillingLimitActiveOrg,
+  BillingLimitConfiguredCustom,
+  BillingLimitConfiguredNone,
+  BillingLimitConfiguredPlan,
+  BillingLimitPendingResolveOrg,
+  BillingLimitResult,
+  BillingLimitState,
+  BillingLimitUnconfigured,
+  BillingLimitsActiveResult,
+  BillingLimitsPendingResolvesResult,
   CreatePrivateLinkConnectionBody,
   CurrentPlan,
   CustomerPortalRequestBodySchema,
@@ -748,6 +944,7 @@ export {
   ErrorSchema,
   FreeConnectRequiredSchema,
   FreeConnectedSchema,
+  MAX_INVOCATION_COST_IN_CENTS,
   PlanDefinitionSchema,
   Plans,
   PlansResult,
@@ -755,12 +952,14 @@ export {
   PrivateLinkConnectionList,
   PrivateLinkConnectionStatus,
   PrivateLinkRegionsResult,
+  PromoCreditsResult,
   RegistryCredentialsResponseSchema,
   ReportComputeUsageEvent,
   ReportInvocationUsageEvent,
   ReportInvocationUsageResult,
   ReportUsagePlan,
   ReportUsageResult,
+  ResolveBillingLimitRequest,
   SetAddOnBody,
   SetAddOnResult,
   SetPlanBodySchema,
@@ -769,10 +968,13 @@ export {
   TriggerInitialDeploymentRequestSchema,
   TriggerInitialDeploymentResponseSchema,
   UpdateBillingAlertsRequest,
+  UpdateBillingLimitRequest,
   UsageParams,
   UsageResult,
   UsageSeriesParams,
   UsageSeriesResult,
+  ValidatePromoCodeBodySchema,
+  ValidatePromoCodeResult,
   defaultMachine,
   machineDefinition,
   machines,