@trigger.dev/platform 1.3.1 → 1.4.0

package/dist/index.cjs

@@ -1,1014 +1,850 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let zod = require("zod");
+//#region src/v3/schemas/planDefinitions.ts
+const ExceedableLimit = zod.z.object({
+	number: zod.z.number(),
+	canExceed: zod.z.boolean().optional()
+});
+const EnvironmentBasedLimit = zod.z.object({
+	production: zod.z.number(),
+	staging: zod.z.number(),
+	preview: zod.z.number(),
+	development: zod.z.number(),
+	canExceed: zod.z.boolean().optional(),
+	number: zod.z.number()
+});
+const BatchRateLimitConfig = zod.z.object({
+	type: zod.z.string(),
+	interval: zod.z.string(),
+	maxTokens: zod.z.number(),
+	refillRate: zod.z.number()
+});
+const BatchQueueConcurrencyConfig = zod.z.object({ processingConcurrency: zod.z.number() });
+/**
+* Hosted webhook limits, synced into Organization.webhookLimitsConfig on plan changes. The webapp
+* falls back to its env defaults for any field that isn't set.
+*/
+const WebhookLimitsConfig = zod.z.object({
+	maxWaitersPerEnvironment: zod.z.number(),
+	maxWaitersPerEndpoint: zod.z.number(),
+	concurrency: zod.z.number(),
+	deliveryRetentionDays: zod.z.number(),
+	deliveryRetentionStrict: zod.z.boolean().optional(),
+	endpointRateLimitTokens: zod.z.number().optional(),
+	endpointRateLimitWindowSeconds: zod.z.number().optional(),
+	environmentRateLimitTokens: zod.z.number().optional(),
+	environmentRateLimitWindowSeconds: zod.z.number().optional()
+});
+const QueueSizeLimits = zod.z.object({
+	development: zod.z.number(),
+	deployed: zod.z.number()
+});
+const Limits = zod.z.object({
+	includedUsage: zod.z.number(),
+	concurrentRuns: EnvironmentBasedLimit,
+	teamMembers: ExceedableLimit,
+	schedules: ExceedableLimit,
+	logRetentionDays: ExceedableLimit,
+	queryPeriodDays: ExceedableLimit,
+	alerts: ExceedableLimit,
+	hasStagingEnvironment: zod.z.boolean(),
+	realtimeConcurrentConnections: ExceedableLimit,
+	branches: ExceedableLimit,
+	branchesDev: ExceedableLimit,
+	support: zod.z.enum(["community", "slack"]),
+	batchRateLimitConfig: BatchRateLimitConfig.optional(),
+	batchQueueConcurrencyConfig: BatchQueueConcurrencyConfig.optional(),
+	webhookLimitsConfig: WebhookLimitsConfig.optional(),
+	metricDashboards: ExceedableLimit,
+	metricWidgetsPerDashboard: ExceedableLimit,
+	agentMessages: ExceedableLimit.optional(),
+	agentWatchMaxHours: ExceedableLimit.optional(),
+	agentWatchers: ExceedableLimit.optional(),
+	declaredSchedulesPerDeploy: ExceedableLimit.optional(),
+	queueSizeLimits: QueueSizeLimits.optional(),
+	hasPrivateNetworking: zod.z.boolean().optional(),
+	privateLinkConnectionLimit: zod.z.number().optional(),
+	hasSso: zod.z.boolean().optional(),
+	streamBasinRetention: zod.z.string().optional()
+});
+const commonMetadata = {
+	title: zod.z.string(),
+	code: zod.z.string()
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+const pricingLookup = {
+	tierPriceCode: zod.z.string(),
+	usagePriceCode: zod.z.string(),
+	usageCouponCode: zod.z.string().optional()
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/v3/index.ts
-var v3_exports = {};
-__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,
-  CustomerPortalSchema: () => CustomerPortalSchema,
-  DeletePrivateLinkResult: () => DeletePrivateLinkResult,
-  EnqueueBuildRequestSchema: () => EnqueueBuildRequestSchema,
-  EnqueueBuildResponseSchema: () => EnqueueBuildResponseSchema,
-  ErrorSchema: () => ErrorSchema,
-  FreeConnectRequiredSchema: () => FreeConnectRequiredSchema,
-  FreeConnectedSchema: () => FreeConnectedSchema,
-  MAX_INVOCATION_COST_IN_CENTS: () => MAX_INVOCATION_COST_IN_CENTS,
-  PlanDefinitionSchema: () => PlanDefinitionSchema,
-  Plans: () => Plans,
-  PlansResult: () => PlansResult,
-  PrivateLinkConnection: () => PrivateLinkConnection,
-  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,
-  SubscribeResultSchema: () => SubscribeResultSchema,
-  SubscriptionResult: () => SubscriptionResult,
-  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,
-  objectToSearchParams: () => objectToSearchParams
-});
-module.exports = __toCommonJS(v3_exports);
-
-// src/v3/schemas/planDefinitions.ts
-var import_zod = require("zod");
-var ExceedableLimit = import_zod.z.object({
-  number: import_zod.z.number(),
-  canExceed: import_zod.z.boolean().optional()
-});
-var EnvironmentBasedLimit = import_zod.z.object({
-  production: import_zod.z.number(),
-  staging: import_zod.z.number(),
-  preview: import_zod.z.number(),
-  development: import_zod.z.number(),
-  canExceed: import_zod.z.boolean().optional(),
-  // Legacy, return the `production` value
-  number: import_zod.z.number()
-});
-var BatchRateLimitConfig = import_zod.z.object({
-  type: import_zod.z.string(),
-  interval: import_zod.z.string(),
-  maxTokens: import_zod.z.number(),
-  refillRate: import_zod.z.number()
-});
-var BatchQueueConcurrencyConfig = import_zod.z.object({
-  processingConcurrency: import_zod.z.number()
-});
-var QueueSizeLimits = import_zod.z.object({
-  development: import_zod.z.number(),
-  deployed: import_zod.z.number()
-});
-var Limits = import_zod.z.object({
-  includedUsage: import_zod.z.number(),
-  concurrentRuns: EnvironmentBasedLimit,
-  teamMembers: ExceedableLimit,
-  schedules: ExceedableLimit,
-  logRetentionDays: ExceedableLimit,
-  queryPeriodDays: ExceedableLimit,
-  alerts: ExceedableLimit,
-  hasStagingEnvironment: import_zod.z.boolean(),
-  realtimeConcurrentConnections: ExceedableLimit,
-  branches: ExceedableLimit,
-  branchesDev: ExceedableLimit,
-  support: import_zod.z.enum(["community", "slack"]),
-  batchRateLimitConfig: BatchRateLimitConfig.optional(),
-  batchQueueConcurrencyConfig: BatchQueueConcurrencyConfig.optional(),
-  metricDashboards: ExceedableLimit,
-  metricWidgetsPerDashboard: ExceedableLimit,
-  queueSizeLimits: QueueSizeLimits.optional(),
-  hasPrivateNetworking: import_zod.z.boolean().optional(),
-  privateLinkConnectionLimit: import_zod.z.number().optional(),
-  hasSso: import_zod.z.boolean().optional(),
-  // Duration string (e.g. "30d", "1y"). When set, the org gets a
-  // dedicated S2 stream basin with this retention; when omitted, the
-  // org's streams flow to the shared global basin.
-  streamBasinRetention: import_zod.z.string().optional()
-});
-var commonMetadata = {
-  title: import_zod.z.string(),
-  code: import_zod.z.string()
-};
-var pricingLookup = {
-  tierPriceCode: import_zod.z.string(),
-  usagePriceCode: import_zod.z.string(),
-  usageCouponCode: import_zod.z.string().optional()
-};
-var FreePlanDefinition = import_zod.z.object({
-  ...commonMetadata,
-  type: import_zod.z.literal("free"),
-  limits: Limits
-});
-var PaidPlanDefinition = import_zod.z.object({
-  ...commonMetadata,
-  type: import_zod.z.literal("paid"),
-  tierPrice: import_zod.z.number(),
-  stripe: import_zod.z.object(pricingLookup),
-  limits: Limits
-});
-var EnterprisePlanDefinition = import_zod.z.object({
-  ...commonMetadata,
-  type: import_zod.z.literal("enterprise"),
-  limits: Limits
-});
-var PlanDefinitionSchema = import_zod.z.discriminatedUnion("type", [
-  FreePlanDefinition,
-  PaidPlanDefinition,
-  EnterprisePlanDefinition
+const FreePlanDefinition = zod.z.object({
+	...commonMetadata,
+	type: zod.z.literal("free"),
+	limits: Limits
+});
+const PaidPlanDefinition = zod.z.object({
+	...commonMetadata,
+	type: zod.z.literal("paid"),
+	tierPrice: zod.z.number(),
+	stripe: zod.z.object(pricingLookup),
+	limits: Limits
+});
+const EnterprisePlanDefinition = zod.z.object({
+	...commonMetadata,
+	type: zod.z.literal("enterprise"),
+	limits: Limits
+});
+const PlanDefinitionSchema = zod.z.discriminatedUnion("type", [
+	FreePlanDefinition,
+	PaidPlanDefinition,
+	EnterprisePlanDefinition
 ]);
-var MachineDefinition = import_zod.z.object({
-  code: import_zod.z.string(),
-  title: import_zod.z.string(),
-  cpu: import_zod.z.number(),
-  memory: import_zod.z.number(),
-  centsPerMs: import_zod.z.number()
-});
-var Plans = import_zod.z.object({
-  free: FreePlanDefinition,
-  hobby: PaidPlanDefinition,
-  pro: PaidPlanDefinition,
-  enterprise: EnterprisePlanDefinition
-});
-var AddOnPricing = import_zod.z.object({
-  /** The step size - must purchase in multiples of this amount */
-  stepSize: import_zod.z.number(),
-  /** Price per step in cents */
-  centsPerStep: import_zod.z.number()
-});
-var PlansResult = import_zod.z.object({
-  plans: Plans,
-  usagePricing: import_zod.z.object({
-    centsPerRunInvocation: import_zod.z.number(),
-    machines: import_zod.z.record(import_zod.z.string(), MachineDefinition),
-    defaultMachine: import_zod.z.string()
-  }),
-  addOnPricing: import_zod.z.object({
-    concurrency: AddOnPricing,
-    branches: AddOnPricing,
-    seats: AddOnPricing,
-    schedules: AddOnPricing
-  })
-});
-var AddOnDefinition = import_zod.z.object({
-  code: import_zod.z.enum(["concurrency", "branches", "seats", "schedules"]),
-  priceCode: import_zod.z.string(),
-  pricing: AddOnPricing
-});
-var AddOn = import_zod.z.object({
-  purchased: import_zod.z.number(),
-  quota: import_zod.z.number().optional()
-});
-var AddOns = import_zod.z.object({
-  concurrentRuns: AddOn.optional(),
-  branches: AddOn.optional(),
-  seats: AddOn.optional(),
-  schedules: AddOn.optional()
-});
-
-// src/v3/schemas/subscription.ts
-var import_zod2 = require("zod");
-var FreeTierStatus = import_zod2.z.enum(["requires_connect", "approved", "rejected"]);
-var SubscriptionResult = import_zod2.z.object({
-  freeTierStatus: FreeTierStatus,
-  isPaying: import_zod2.z.boolean(),
-  showSelfServe: import_zod2.z.boolean().default(true),
-  canceledAt: import_zod2.z.string().optional(),
-  plan: PlanDefinitionSchema.optional(),
-  addOns: AddOns.optional()
-});
-var CurrentPlan = import_zod2.z.object({
-  //todo remove this after the next deploy
-  subscription: import_zod2.z.any(),
-  v3Subscription: SubscriptionResult
-});
-
-// src/v3/schemas/subscribe.ts
-var import_zod3 = require("zod");
-var SetPaidPlanBodySchema = import_zod3.z.object({
-  type: import_zod3.z.literal("paid"),
-  planCode: import_zod3.z.string(),
-  userId: import_zod3.z.string()
-});
-var SetFreePlanBodySchema = import_zod3.z.object({
-  type: import_zod3.z.literal("free"),
-  userId: import_zod3.z.string()
-});
-var SetPlanBodySchema = import_zod3.z.discriminatedUnion("type", [
-  SetPaidPlanBodySchema,
-  SetFreePlanBodySchema
+const MachineDefinition = zod.z.object({
+	code: zod.z.string(),
+	title: zod.z.string(),
+	cpu: zod.z.number(),
+	memory: zod.z.number(),
+	centsPerMs: zod.z.number()
+});
+const Plans = zod.z.object({
+	free: FreePlanDefinition,
+	hobby: PaidPlanDefinition,
+	pro: PaidPlanDefinition,
+	enterprise: EnterprisePlanDefinition
+});
+/** The pricing per step of the add-on, e.g. $10 for 50 units */
+const AddOnPricing = zod.z.object({
+	/** The step size - must purchase in multiples of this amount */
+	stepSize: zod.z.number(),
+	/** Price per step in cents */
+	centsPerStep: zod.z.number()
+});
+const PlansResult = zod.z.object({
+	plans: Plans,
+	usagePricing: zod.z.object({
+		centsPerRunInvocation: zod.z.number(),
+		machines: zod.z.record(zod.z.string(), MachineDefinition),
+		defaultMachine: zod.z.string()
+	}),
+	addOnPricing: zod.z.object({
+		concurrency: AddOnPricing,
+		branches: AddOnPricing,
+		seats: AddOnPricing,
+		schedules: AddOnPricing
+	})
+});
+const AddOnDefinition = zod.z.object({
+	code: zod.z.enum([
+		"concurrency",
+		"branches",
+		"seats",
+		"schedules"
+	]),
+	priceCode: zod.z.string(),
+	pricing: AddOnPricing
+});
+const AddOn = zod.z.object({
+	purchased: zod.z.number(),
+	quota: zod.z.number().optional()
+});
+const AddOns = zod.z.object({
+	concurrentRuns: AddOn.optional(),
+	branches: AddOn.optional(),
+	seats: AddOn.optional(),
+	schedules: AddOn.optional()
+});
+//#endregion
+//#region src/v3/schemas/subscription.ts
+const FreeTierStatus = zod.z.enum([
+	"requires_connect",
+	"approved",
+	"rejected"
 ]);
-var FreeConnectRequiredSchema = import_zod3.z.object({
-  action: import_zod3.z.literal("free_connect_required"),
-  connectUrl: import_zod3.z.string().url()
-});
-var FreeConnectedSchema = import_zod3.z.object({
-  action: import_zod3.z.literal("free_connected"),
-  accepted: import_zod3.z.boolean()
-});
-var UpdatedSubscriptionResultSchema = import_zod3.z.object({
-  action: import_zod3.z.literal("updated_subscription"),
-  subscription: import_zod3.z.object({
-    planCode: import_zod3.z.string()
-  })
-});
-var CreateSubscriptionFlowStartSchema = import_zod3.z.object({
-  action: import_zod3.z.literal("create_subscription_flow_start"),
-  subscription: import_zod3.z.object({
-    planCode: import_zod3.z.string()
-  }),
-  checkoutUrl: import_zod3.z.string().url()
-});
-var CanceledSubscriptionResultSchema = import_zod3.z.object({
-  action: import_zod3.z.literal("canceled_subscription")
-});
-var SubscribeResultSchema = import_zod3.z.discriminatedUnion("action", [
-  FreeConnectRequiredSchema,
-  FreeConnectedSchema,
-  CreateSubscriptionFlowStartSchema,
-  UpdatedSubscriptionResultSchema,
-  CanceledSubscriptionResultSchema
+const SubscriptionResult = zod.z.object({
+	freeTierStatus: FreeTierStatus,
+	isPaying: zod.z.boolean(),
+	showSelfServe: zod.z.boolean().default(true),
+	canceledAt: zod.z.string().optional(),
+	plan: PlanDefinitionSchema.optional(),
+	addOns: AddOns.optional()
+});
+const CurrentPlan = zod.z.object({
+	subscription: zod.z.any(),
+	v3Subscription: SubscriptionResult
+});
+//#endregion
+//#region src/v3/schemas/subscribe.ts
+const SetPaidPlanBodySchema = zod.z.object({
+	type: zod.z.literal("paid"),
+	planCode: zod.z.string(),
+	userId: zod.z.string()
+});
+const SetFreePlanBodySchema = zod.z.object({
+	type: zod.z.literal("free"),
+	userId: zod.z.string()
+});
+const SetPlanBodySchema = zod.z.discriminatedUnion("type", [SetPaidPlanBodySchema, SetFreePlanBodySchema]);
+const FreeConnectRequiredSchema = zod.z.object({
+	action: zod.z.literal("free_connect_required"),
+	connectUrl: zod.z.string().url()
+});
+const FreeConnectedSchema = zod.z.object({
+	action: zod.z.literal("free_connected"),
+	accepted: zod.z.boolean()
+});
+const UpdatedSubscriptionResultSchema = zod.z.object({
+	action: zod.z.literal("updated_subscription"),
+	subscription: zod.z.object({ planCode: zod.z.string() })
+});
+const CreateSubscriptionFlowStartSchema = zod.z.object({
+	action: zod.z.literal("create_subscription_flow_start"),
+	subscription: zod.z.object({ planCode: zod.z.string() }),
+	checkoutUrl: zod.z.string().url()
+});
+const CanceledSubscriptionResultSchema = zod.z.object({ action: zod.z.literal("canceled_subscription") });
+const SubscribeResultSchema = zod.z.discriminatedUnion("action", [
+	FreeConnectRequiredSchema,
+	FreeConnectedSchema,
+	CreateSubscriptionFlowStartSchema,
+	UpdatedSubscriptionResultSchema,
+	CanceledSubscriptionResultSchema
 ]);
-var SetAddOnBody = import_zod3.z.object({
-  type: import_zod3.z.enum(["concurrency", "branches", "seats", "schedules"]),
-  amount: import_zod3.z.number()
-});
-var SetAddOnResult = import_zod3.z.discriminatedUnion("result", [
-  import_zod3.z.object({
-    result: import_zod3.z.literal("error"),
-    error: import_zod3.z.string()
-  }),
-  import_zod3.z.object({
-    result: import_zod3.z.literal("success"),
-    type: import_zod3.z.string(),
-    amount: import_zod3.z.number(),
-    subscription: import_zod3.z.object({
-      id: import_zod3.z.string()
-    })
-  }),
-  import_zod3.z.object({
-    result: import_zod3.z.literal("max_quota_reached"),
-    type: import_zod3.z.string(),
-    maxQuota: import_zod3.z.number()
-  })
+const SetAddOnBody = zod.z.object({
+	type: zod.z.enum([
+		"concurrency",
+		"branches",
+		"seats",
+		"schedules"
+	]),
+	amount: zod.z.number()
+});
+const SetAddOnResult = zod.z.discriminatedUnion("result", [
+	zod.z.object({
+		result: zod.z.literal("error"),
+		error: zod.z.string()
+	}),
+	zod.z.object({
+		result: zod.z.literal("success"),
+		type: zod.z.string(),
+		amount: zod.z.number(),
+		subscription: zod.z.object({ id: zod.z.string() })
+	}),
+	zod.z.object({
+		result: zod.z.literal("max_quota_reached"),
+		type: zod.z.string(),
+		maxQuota: zod.z.number()
+	})
 ]);
-
-// src/v3/schemas/portal.ts
-var import_zod4 = require("zod");
-var CustomerPortalRequestBodySchema = import_zod4.z.object({
-  returnUrl: import_zod4.z.string()
-});
-var CustomerPortalSchema = import_zod4.z.object({
-  customerPortalUrl: import_zod4.z.string().optional()
-});
-
-// src/v3/schemas/error.ts
-var import_zod5 = require("zod");
-var ErrorSchema = import_zod5.z.object({
-  error: import_zod5.z.string(),
-  code: import_zod5.z.string().optional()
+const CancelSubscriptionResponse = zod.z.object({
+	outcome: zod.z.enum([
+		"canceled",
+		"already_canceled",
+		"no_subscription"
+	]),
+	cancelAt: zod.z.string().nullable()
+});
+//#endregion
+//#region src/v3/schemas/portal.ts
+const CustomerPortalRequestBodySchema = zod.z.object({ returnUrl: zod.z.string() });
+const CustomerPortalSchema = zod.z.object({ customerPortalUrl: zod.z.string().optional() });
+//#endregion
+//#region src/v3/schemas/error.ts
+const ErrorSchema = zod.z.object({
+	error: zod.z.string(),
+	code: zod.z.string().optional()
 }).passthrough();
-
-// src/v3/schemas/usage.ts
-var import_zod6 = require("zod");
-var UsageParams = import_zod6.z.object({
-  from: import_zod6.z.coerce.date(),
-  to: import_zod6.z.coerce.date()
-});
-var UsageResult = import_zod6.z.object({
-  cents: import_zod6.z.number()
-});
-var Window = import_zod6.z.enum(["MINUTE", "HOUR", "DAY"]);
-var UsageSeriesParams = import_zod6.z.object({
-  from: import_zod6.z.coerce.date(),
-  to: import_zod6.z.coerce.date(),
-  /** defaults to DAY */
-  window: Window.optional(),
-  timezone: import_zod6.z.string().optional()
-  //these don't work at the moment because you can't group by items that aren't defined in the meter group by
-  // groupByEnvironmentType: BooleanParam.optional(),
-  // groupByTaskIdentifier: BooleanParam.optional(),
-});
-var UsageSeriesResult = import_zod6.z.object({
-  from: import_zod6.z.string(),
-  to: import_zod6.z.string(),
-  window: Window.optional(),
-  data: import_zod6.z.object({
-    value: import_zod6.z.number(),
-    windowStart: import_zod6.z.string(),
-    windowEnd: import_zod6.z.string()
-    //these don't work at the moment
-    // groupBy: z
-    //   .object({
-    //     environmentType: z.string().optional(),
-    //     taskIdentifer: z.string().optional(),
-    //   })
-    //   .optional(),
-  }).array()
-});
-var ReportComputeUsageEvent = import_zod6.z.object({
-  durationMs: import_zod6.z.number()
-});
-var ReportUsagePlan = import_zod6.z.object({
-  type: import_zod6.z.string(),
-  code: import_zod6.z.string(),
-  isPaying: import_zod6.z.boolean()
-});
-var ReportUsageResult = import_zod6.z.object({
-  hasAccess: import_zod6.z.boolean(),
-  balance: import_zod6.z.number().optional(),
-  usage: import_zod6.z.number().optional(),
-  overage: import_zod6.z.number().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().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({
-    success: import_zod6.z.literal(true)
-  }),
-  import_zod6.z.object({
-    success: import_zod6.z.literal(false),
-    error: import_zod6.z.string()
-  })
+//#endregion
+//#region src/v3/schemas/usage.ts
+const UsageParams = zod.z.object({
+	from: zod.z.coerce.date(),
+	to: zod.z.coerce.date()
+});
+const UsageResult = zod.z.object({ cents: zod.z.number() });
+const Window = zod.z.enum([
+	"MINUTE",
+	"HOUR",
+	"DAY"
 ]);
-
-// src/v3/schemas/billingAlerts.ts
-var import_zod7 = require("zod");
-var BillingAlertDefinition = import_zod7.z.object({
-  amount: import_zod7.z.number(),
-  emails: import_zod7.z.array(import_zod7.z.string()),
-  alertLevels: import_zod7.z.array(import_zod7.z.number())
-});
-var BillingAlertsResult = BillingAlertDefinition;
-var UpdateBillingAlertsRequest = import_zod7.z.object({
-  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/billingLimit.ts
-var import_zod8 = require("zod");
-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()
-  })
+const UsageSeriesParams = zod.z.object({
+	from: zod.z.coerce.date(),
+	to: zod.z.coerce.date(),
+	/** defaults to DAY */
+	window: Window.optional(),
+	timezone: zod.z.string().optional()
+});
+const UsageSeriesResult = zod.z.object({
+	from: zod.z.string(),
+	to: zod.z.string(),
+	window: Window.optional(),
+	data: zod.z.object({
+		value: zod.z.number(),
+		windowStart: zod.z.string(),
+		windowEnd: zod.z.string()
+	}).array()
+});
+const ReportComputeUsageEvent = zod.z.object({ durationMs: zod.z.number() });
+const ReportUsagePlan = zod.z.object({
+	type: zod.z.string(),
+	code: zod.z.string(),
+	isPaying: zod.z.boolean()
+});
+const ReportUsageResult = zod.z.object({
+	hasAccess: zod.z.boolean(),
+	balance: zod.z.number().optional(),
+	usage: zod.z.number().optional(),
+	overage: zod.z.number().optional(),
+	plan: ReportUsagePlan.optional(),
+	limitState: zod.z.literal("grace").optional(),
+	reason: zod.z.enum(["free_tier_exceeded", "billing_limit"]).optional()
+});
+/** Upper bound for a single invocation base charge ($100). */
+const MAX_INVOCATION_COST_IN_CENTS = 1e4;
+const ReportInvocationUsageEvent = zod.z.object({
+	organizationId: zod.z.string().min(1).max(128),
+	costInCents: zod.z.number().finite().min(0).max(MAX_INVOCATION_COST_IN_CENTS),
+	additionalData: zod.z.record(zod.z.string(), zod.z.any()).optional()
+});
+const ReportInvocationUsageResult = zod.z.discriminatedUnion("success", [zod.z.object({ success: zod.z.literal(true) }), zod.z.object({
+	success: zod.z.literal(false),
+	error: zod.z.string()
+})]);
+const BillingAlertsResult = zod.z.object({
+	amount: zod.z.number(),
+	emails: zod.z.array(zod.z.string()),
+	alertLevels: zod.z.array(zod.z.number())
+});
+const UpdateBillingAlertsRequest = zod.z.object({
+	amount: zod.z.number().positive(),
+	emails: zod.z.array(zod.z.string()),
+	alertLevels: zod.z.array(zod.z.number())
+});
+//#endregion
+//#region src/v3/schemas/billingLimit.ts
+const BillingLimitState = zod.z.discriminatedUnion("status", [
+	zod.z.object({ status: zod.z.literal("ok") }),
+	zod.z.object({
+		status: zod.z.literal("grace"),
+		hitAt: zod.z.string(),
+		graceEndsAt: zod.z.string()
+	}),
+	zod.z.object({
+		status: zod.z.literal("rejected"),
+		hitAt: zod.z.string(),
+		graceEndsAt: zod.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()
+const billingLimitConfiguredFields = {
+	isConfigured: zod.z.literal(true),
+	cancelInProgressRuns: zod.z.boolean(),
+	limitState: BillingLimitState,
+	effectiveAmountCents: zod.z.number().int().nonnegative().nullable(),
+	gracePeriodMs: zod.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
+const BillingLimitUnconfigured = zod.z.object({
+	isConfigured: zod.z.literal(false),
+	gracePeriodMs: zod.z.number().int().nonnegative()
+});
+const BillingLimitConfiguredNone = zod.z.object({
+	...billingLimitConfiguredFields,
+	mode: zod.z.literal("none")
+});
+const BillingLimitConfiguredPlan = zod.z.object({
+	...billingLimitConfiguredFields,
+	mode: zod.z.literal("plan")
+});
+const BillingLimitConfiguredCustom = zod.z.object({
+	...billingLimitConfiguredFields,
+	mode: zod.z.literal("custom"),
+	amountCents: zod.z.number().int().positive()
+});
+const BillingLimitResult = zod.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()
-  })
+const UpdateBillingLimitRequest = zod.z.discriminatedUnion("mode", [
+	zod.z.object({
+		mode: zod.z.literal("none"),
+		cancelInProgressRuns: zod.z.boolean()
+	}),
+	zod.z.object({
+		mode: zod.z.literal("plan"),
+		cancelInProgressRuns: zod.z.boolean()
+	}),
+	zod.z.object({
+		mode: zod.z.literal("custom"),
+		amountCents: zod.z.number().int().positive(),
+		cancelInProgressRuns: zod.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"])
-  })
+const ResolveBillingLimitRequest = zod.z.discriminatedUnion("action", [zod.z.object({
+	action: zod.z.literal("increase"),
+	newAmountCents: zod.z.number().int().positive(),
+	resumeMode: zod.z.enum(["queue", "new_only"])
+}), zod.z.object({
+	action: zod.z.literal("remove"),
+	resumeMode: zod.z.enum(["queue", "new_only"])
+})]);
+const BillingLimitActiveOrg = zod.z.object({
+	orgId: zod.z.string(),
+	limitState: zod.z.enum(["grace", "rejected"])
+});
+const BillingLimitsActiveResult = zod.z.object({ orgs: zod.z.array(BillingLimitActiveOrg) });
+const BillingLimitPendingResolveOrg = zod.z.object({
+	organizationId: zod.z.string(),
+	resumeMode: zod.z.enum(["queue", "new_only"]),
+	resolvedAt: zod.z.string()
+});
+const BillingLimitsPendingResolvesResult = zod.z.object({ orgs: zod.z.array(BillingLimitPendingResolveOrg) });
+//#endregion
+//#region src/v3/schemas/registryCredentials.ts
+const RegistryCredentialsResponseSchema = zod.z.object({
+	username: zod.z.string(),
+	password: zod.z.string(),
+	expiresAt: zod.z.string().datetime(),
+	repositoryUri: zod.z.string()
+});
+//#endregion
+//#region src/v3/schemas/enqueueBuild.ts
+const EnqueueBuildOptionsSchema = zod.z.object({
+	skipPromotion: zod.z.boolean().optional(),
+	configFilePath: zod.z.string().optional(),
+	fromBundle: zod.z.boolean().optional()
+});
+const EnqueueBuildRequestSchema = zod.z.union([zod.z.object({
+	deploymentId: zod.z.string(),
+	artifactKey: zod.z.string(),
+	options: EnqueueBuildOptionsSchema
+}), zod.z.object({
+	deploymentId: zod.z.string(),
+	github: zod.z.object({
+		commitSha: zod.z.string().regex(/^[0-9a-f]{40}$/, "commitSha must be a full lowercase git SHA"),
+		ref: zod.z.string().min(1).max(255)
+	}),
+	options: EnqueueBuildOptionsSchema
+})]);
+const EnqueueBuildResponseSchema = zod.z.object({ buildId: zod.z.string() });
+const EnqueueBuildErrorCodeSchema = zod.z.enum([
+	"DEPLOYMENT_NOT_PENDING",
+	"NO_CONNECTED_REPOSITORY",
+	"ATOMIC_PRODUCTION_REQUIRES_VERCEL",
+	"COMMIT_NOT_FOUND",
+	"GITHUB_UNAVAILABLE"
 ]);
-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/registryCredentials.ts
-var import_zod9 = require("zod");
-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_zod10.z.object({
-  buildId: import_zod10.z.string()
-});
-
-// src/v3/schemas/initialDeployment.ts
-var import_zod11 = require("zod");
-var TriggerInitialDeploymentRequestSchema = import_zod11.z.object({
-  environment: import_zod11.z.enum(["prod", "staging", "preview"])
-});
-var TriggerInitialDeploymentResponseSchema = import_zod11.z.object({
-  ok: import_zod11.z.boolean()
-});
-
-// src/v3/schemas/privateLink.ts
-var import_zod12 = require("zod");
-var PrivateLinkConnectionStatus = import_zod12.z.enum([
-  "PENDING",
-  "PROVISIONING",
-  "ACTIVE",
-  "ERROR",
-  "DELETING"
+//#endregion
+//#region src/v3/schemas/initialDeployment.ts
+const TriggerInitialDeploymentRequestSchema = zod.z.object({
+	environment: zod.z.enum([
+		"prod",
+		"staging",
+		"preview"
+	]),
+	branch: zod.z.string().min(1).max(255).optional()
+});
+const TriggerInitialDeploymentResponseSchema = zod.z.object({ ok: zod.z.boolean() });
+//#endregion
+//#region src/v3/schemas/privateLink.ts
+const PrivateLinkConnectionStatus = zod.z.enum([
+	"PENDING",
+	"PROVISIONING",
+	"ACTIVE",
+	"ERROR",
+	"DELETING"
 ]);
-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_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_zod12.z.string().regex(
-    /^com\.amazonaws\.vpce\..+\.vpce-svc-.+$/,
-    "Must be a valid VPC Endpoint Service name (com.amazonaws.vpce.<region>.vpce-svc-*)"
-  ),
-  // Region support is dynamic (driven by the billing service's env vars), so
-  // 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_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 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 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
+const PrivateLinkConnection = zod.z.object({
+	id: zod.z.string(),
+	friendlyId: zod.z.string(),
+	name: zod.z.string(),
+	organizationId: zod.z.string(),
+	endpointServiceName: zod.z.string(),
+	targetRegion: zod.z.string(),
+	status: PrivateLinkConnectionStatus,
+	statusMessage: zod.z.string().nullable(),
+	endpointDnsName: zod.z.string().nullable(),
+	endpointIps: zod.z.array(zod.z.string()).nullable(),
+	provisionedAt: zod.z.string().nullable(),
+	createdAt: zod.z.string(),
+	updatedAt: zod.z.string()
+});
+const PrivateLinkConnectionList = zod.z.object({ connections: zod.z.array(PrivateLinkConnection) });
+const CreatePrivateLinkConnectionBody = zod.z.object({
+	name: zod.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: zod.z.string().regex(/^com\.amazonaws\.vpce\..+\.vpce-svc-.+$/, "Must be a valid VPC Endpoint Service name (com.amazonaws.vpce.<region>.vpce-svc-*)"),
+	targetRegion: zod.z.string().regex(/^[a-z]{2}-[a-z]+-\d+$/, "Must be a valid AWS region")
+});
+const DeletePrivateLinkResult = zod.z.object({ success: zod.z.boolean() });
+const PrivateLinkRegionsResult = zod.z.object({
+	availableRegions: zod.z.array(zod.z.string()),
+	activeRegions: zod.z.array(zod.z.string())
+});
+//#endregion
+//#region src/v3/schemas/promoCodes.ts
+const ValidatePromoCodeBodySchema = zod.z.object({ code: zod.z.string() });
+const ValidatePromoCodeResult = zod.z.object({
+	valid: zod.z.boolean(),
+	amountInCents: zod.z.number().optional(),
+	expiresAt: zod.z.string().datetime().nullable().optional()
+});
+const ApplyPromoCodeBodySchema = zod.z.object({
+	code: zod.z.string(),
+	userId: zod.z.string()
+});
+const ApplyPromoCodeResult = zod.z.object({
+	applied: zod.z.boolean(),
+	amountInCents: zod.z.number().optional(),
+	expiresAt: zod.z.string().datetime().nullable().optional(),
+	reason: zod.z.string().optional()
+});
+const PromoCreditsResult = zod.z.object({ promoCredits: zod.z.object({
+	grantedCents: zod.z.number(),
+	remainingCents: zod.z.number(),
+	expiresAt: zod.z.string().datetime().nullable()
+}).nullable() });
+//#endregion
+//#region src/v3/client/index.ts
 var BillingClient = class {
-  constructor(config) {
-    this.config = config;
-  }
-  async plans() {
-    return await this.fetch(`/api/v1/plans/v3`, PlansResult);
-  }
-  async currentPlan(orgId) {
-    return await this.fetch(`/api/v1/orgs/${orgId}`, CurrentPlan);
-  }
-  async usage(orgId, params) {
-    const search = objectToSearchParams(params);
-    return await this.fetch(`/api/v1/orgs/${orgId}/usage?${search == null ? void 0 : search.toString()}`, UsageResult);
-  }
-  async usageSeries(orgId, params) {
-    const search = objectToSearchParams(params);
-    return await this.fetch(
-      `/api/v1/orgs/${orgId}/usage/series?${search == null ? void 0 : search.toString()}`,
-      UsageSeriesResult
-    );
-  }
-  async setPlan(orgId, body) {
-    return await this.fetch(`/api/v1/orgs/${orgId}/v3/subscription`, SubscribeResultSchema, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-  }
-  async setAddOn(orgId, body) {
-    return await this.fetch(`/api/v1/orgs/${orgId}/v3/subscription/addon`, SetAddOnResult, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-  }
-  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`, CustomerPortalSchema, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-  }
-  /**
-   *
-   * @param event The data is in the body, not using a JWT
-   * @returns details about usage
-   */
-  async reportInvocationUsage(event) {
-    return await this.fetch(`/api/v1/usage/ingest/invocation`, ReportInvocationUsageResult, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(event)
-    });
-  }
-  /**
-   * Generates registry credentials for a project. This is used to push images to a project's container repository.
-   *
-   * @param projectId The ID of the project
-   * @param region The region to generate credentials for
-   * @returns The registry credentials
-   */
-  async generateRegistryCredentials(projectId, region) {
-    return await this.fetch(
-      `/api/v1/projects/${projectId}/generate-registry-credentials`,
-      RegistryCredentialsResponseSchema,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ region })
-      }
-    );
-  }
-  /**
-   * Enqueues a build for a project deployment.
-   *
-   * @param projectId The ID of the project
-   * @param body The enqueue build request containing the deployment ID
-   * @returns The build ID
-   */
-  async enqueueBuild(projectId, body) {
-    return await this.fetch(
-      `/api/v1/projects/${projectId}/enqueue-build`,
-      EnqueueBuildResponseSchema,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(body)
-      }
-    );
-  }
-  /**
-   *
-   * @param event The data is in the body, not using a JWT
-   * @returns details about usage
-   */
-  async getEntitlement(orgId) {
-    return await this.fetch(`/api/v1/orgs/${orgId}/usage/entitlement`, ReportUsageResult);
-  }
-  async getBillingAlerts(orgId) {
-    return await this.fetch(`/api/v1/orgs/${orgId}/billing-alerts`, BillingAlertsResult);
-  }
-  async updateBillingAlerts(orgId, body) {
-    return await this.fetch(`/api/v1/orgs/${orgId}/billing-alerts`, BillingAlertsResult, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-  }
-  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`, PrivateLinkConnectionList);
-  }
-  async createPrivateLink(orgId, body) {
-    return await this.fetch(`/api/v1/orgs/${orgId}/private-connections`, PrivateLinkConnection, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-  }
-  async deletePrivateLink(orgId, connectionId) {
-    return await this.fetch(
-      `/api/v1/orgs/${orgId}/private-connections/${connectionId}`,
-      DeletePrivateLinkResult,
-      {
-        method: "DELETE"
-      }
-    );
-  }
-  async getPrivateLinkRegions(orgId) {
-    return await this.fetch(
-      `/api/v1/orgs/${orgId}/private-connections/regions`,
-      PrivateLinkRegionsResult
-    );
-  }
-  async triggerInitialDeployment(projectId, body) {
-    return await this.fetch(
-      `/api/v1/projects/${projectId}/initial-deployment`,
-      TriggerInitialDeploymentResponseSchema,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(body)
-      }
-    );
-  }
-  async fetch(path, schema, requestInit) {
-    const response = await fetch(`${this.config.url}${path}`, {
-      ...requestInit,
-      headers: {
-        ...requestInit == null ? void 0 : requestInit.headers,
-        Authorization: `Bearer ${this.config.apiKey}`
-      }
-    });
-    if (!response.ok) {
-      let parsedError;
-      try {
-        parsedError = ErrorSchema.parse(await response.json());
-      } catch {
-        parsedError = { error: `http_${response.status}` };
-      }
-      return {
-        success: false,
-        ...parsedError
-      };
-    }
-    const json = await response.json();
-    const parsed = schema.parse(json);
-    return {
-      success: true,
-      ...parsed
-    };
-  }
+	constructor(config) {
+		this.config = config;
+	}
+	async plans() {
+		return await this.fetch(`/api/v1/plans/v3`, PlansResult);
+	}
+	async currentPlan(orgId) {
+		return await this.fetch(`/api/v1/orgs/${orgId}`, CurrentPlan);
+	}
+	async usage(orgId, params) {
+		const search = objectToSearchParams(params);
+		return await this.fetch(`/api/v1/orgs/${orgId}/usage?${search?.toString()}`, UsageResult);
+	}
+	async usageSeries(orgId, params) {
+		const search = objectToSearchParams(params);
+		return await this.fetch(`/api/v1/orgs/${orgId}/usage/series?${search?.toString()}`, UsageSeriesResult);
+	}
+	async setPlan(orgId, body) {
+		return await this.fetch(`/api/v1/orgs/${orgId}/v3/subscription`, SubscribeResultSchema, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	}
+	async cancelSubscription(orgId) {
+		return await this.fetch(`/api/v1/orgs/${orgId}/v3/subscription/cancel`, CancelSubscriptionResponse, { method: "POST" });
+	}
+	async setAddOn(orgId, body) {
+		return await this.fetch(`/api/v1/orgs/${orgId}/v3/subscription/addon`, SetAddOnResult, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	}
+	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`, CustomerPortalSchema, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	}
+	/**
+	*
+	* @param event The data is in the body, not using a JWT
+	* @returns details about usage
+	*/
+	async reportInvocationUsage(event) {
+		return await this.fetch(`/api/v1/usage/ingest/invocation`, ReportInvocationUsageResult, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(event)
+		});
+	}
+	/**
+	* Generates registry credentials for a project. This is used to push images to a project's container repository.
+	*
+	* @param projectId The ID of the project
+	* @param region The region to generate credentials for
+	* @returns The registry credentials
+	*/
+	async generateRegistryCredentials(projectId, region) {
+		return await this.fetch(`/api/v1/projects/${projectId}/generate-registry-credentials`, RegistryCredentialsResponseSchema, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ region })
+		});
+	}
+	/**
+	* Enqueues a build for a project deployment.
+	*
+	* @param projectId The ID of the project
+	* @param body The enqueue build request containing the deployment ID
+	* @returns The build ID
+	*/
+	async enqueueBuild(projectId, body) {
+		return await this.fetch(`/api/v1/projects/${projectId}/enqueue-build`, EnqueueBuildResponseSchema, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	}
+	/**
+	*
+	* @param event The data is in the body, not using a JWT
+	* @returns details about usage
+	*/
+	async getEntitlement(orgId) {
+		return await this.fetch(`/api/v1/orgs/${orgId}/usage/entitlement`, ReportUsageResult);
+	}
+	async getBillingAlerts(orgId) {
+		return await this.fetch(`/api/v1/orgs/${orgId}/billing-alerts`, BillingAlertsResult);
+	}
+	async updateBillingAlerts(orgId, body) {
+		return await this.fetch(`/api/v1/orgs/${orgId}/billing-alerts`, BillingAlertsResult, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	}
+	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`, PrivateLinkConnectionList);
+	}
+	async createPrivateLink(orgId, body) {
+		return await this.fetch(`/api/v1/orgs/${orgId}/private-connections`, PrivateLinkConnection, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	}
+	async deletePrivateLink(orgId, connectionId) {
+		return await this.fetch(`/api/v1/orgs/${orgId}/private-connections/${connectionId}`, DeletePrivateLinkResult, { method: "DELETE" });
+	}
+	async getPrivateLinkRegions(orgId) {
+		return await this.fetch(`/api/v1/orgs/${orgId}/private-connections/regions`, PrivateLinkRegionsResult);
+	}
+	async triggerInitialDeployment(projectId, body) {
+		return await this.fetch(`/api/v1/projects/${projectId}/initial-deployment`, TriggerInitialDeploymentResponseSchema, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		});
+	}
+	async fetch(path, schema, requestInit) {
+		const response = await fetch(`${this.config.url}${path}`, {
+			...requestInit,
+			headers: {
+				...requestInit?.headers,
+				Authorization: `Bearer ${this.config.apiKey}`
+			}
+		});
+		if (!response.ok) {
+			let parsedError;
+			try {
+				parsedError = ErrorSchema.parse(await response.json());
+			} catch {
+				parsedError = { error: `http_${response.status}` };
+			}
+			return {
+				success: false,
+				...parsedError
+			};
+		}
+		const json = await response.json();
+		return {
+			success: true,
+			...schema.parse(json)
+		};
+	}
 };
 function objectToSearchParams(obj) {
-  if (!obj)
-    return void 0;
-  const searchParams = new URLSearchParams();
-  Object.entries(obj).forEach(([key, value]) => {
-    if (value === void 0)
-      return;
-    if (Array.isArray(value)) {
-      const values = value.map((d) => {
-        if (d instanceof Date)
-          return d.toISOString();
-        return d;
-      });
-      searchParams.append(key, values.join(","));
-    } else {
-      const v = value instanceof Date ? value.toISOString() : value;
-      searchParams.append(key, v.toString());
-    }
-  });
-  return searchParams;
+	if (!obj) return void 0;
+	const searchParams = new URLSearchParams();
+	Object.entries(obj).forEach(([key, value]) => {
+		if (value === void 0) return;
+		if (Array.isArray(value)) {
+			const values = value.map((d) => {
+				if (d instanceof Date) return d.toISOString();
+				return d;
+			});
+			searchParams.append(key, values.join(","));
+		} else {
+			const v = value instanceof Date ? value.toISOString() : value;
+			searchParams.append(key, v.toString());
+		}
+	});
+	return searchParams;
 }
-
-// src/v3/machineDefinition.ts
-function machineDefinition({
-  code,
-  title,
-  cpu,
-  memory,
-  centsPerVCpuSecond: centsPerVCpuSecond2,
-  centsPerGbRamSecond: centsPerGbRamSecond2
-}) {
-  const centsPerSecond = cpu * centsPerVCpuSecond2 + memory * centsPerGbRamSecond2;
-  const centsPerMs = centsPerSecond / 1e3;
-  return {
-    code,
-    title,
-    cpu,
-    memory,
-    centsPerMs
-  };
+//#endregion
+//#region src/v3/machineDefinition.ts
+function machineDefinition({ code, title, cpu, memory, centsPerVCpuSecond, centsPerGbRamSecond }) {
+	return {
+		code,
+		title,
+		cpu,
+		memory,
+		centsPerMs: (cpu * centsPerVCpuSecond + memory * centsPerGbRamSecond) / 1e3
+	};
 }
-
-// src/v3/machinePresets.ts
-var centsPerVCpuSecond = Number(process.env.CENTS_PER_VCPU_SECOND ?? 0);
-var centsPerGbRamSecond = Number(process.env.CENTS_PER_GB_RAM_SECOND ?? 0);
-var machines = {
-  micro: machineDefinition({
-    code: "micro",
-    title: "Micro",
-    cpu: 0.25,
-    memory: 0.25,
-    centsPerVCpuSecond,
-    centsPerGbRamSecond
-  }),
-  "small-1x": machineDefinition({
-    code: "small-1x",
-    title: "Small 1x",
-    cpu: 0.5,
-    memory: 0.5,
-    centsPerVCpuSecond,
-    centsPerGbRamSecond
-  }),
-  "small-2x": machineDefinition({
-    code: "small-2x",
-    title: "Small 2x",
-    cpu: 1,
-    memory: 1,
-    centsPerVCpuSecond,
-    centsPerGbRamSecond
-  }),
-  "medium-1x": machineDefinition({
-    code: "medium-1x",
-    title: "Medium 1x",
-    cpu: 1,
-    memory: 2,
-    centsPerVCpuSecond,
-    centsPerGbRamSecond
-  }),
-  "medium-2x": machineDefinition({
-    code: "medium-2x",
-    title: "Medium 2x",
-    cpu: 2,
-    memory: 4,
-    centsPerVCpuSecond,
-    centsPerGbRamSecond
-  }),
-  "large-1x": machineDefinition({
-    code: "large-1x",
-    title: "Large 1x",
-    cpu: 4,
-    memory: 8,
-    centsPerVCpuSecond,
-    centsPerGbRamSecond
-  }),
-  "large-2x": machineDefinition({
-    code: "large-2x",
-    title: "Large 2x",
-    cpu: 8,
-    memory: 16,
-    centsPerVCpuSecond,
-    centsPerGbRamSecond
-  })
+//#endregion
+//#region src/v3/machinePresets.ts
+const centsPerVCpuSecond = Number(process.env.CENTS_PER_VCPU_SECOND ?? 0);
+const centsPerGbRamSecond = Number(process.env.CENTS_PER_GB_RAM_SECOND ?? 0);
+const machines = {
+	micro: machineDefinition({
+		code: "micro",
+		title: "Micro",
+		cpu: .25,
+		memory: .25,
+		centsPerVCpuSecond,
+		centsPerGbRamSecond
+	}),
+	"small-1x": machineDefinition({
+		code: "small-1x",
+		title: "Small 1x",
+		cpu: .5,
+		memory: .5,
+		centsPerVCpuSecond,
+		centsPerGbRamSecond
+	}),
+	"small-2x": machineDefinition({
+		code: "small-2x",
+		title: "Small 2x",
+		cpu: 1,
+		memory: 1,
+		centsPerVCpuSecond,
+		centsPerGbRamSecond
+	}),
+	"medium-1x": machineDefinition({
+		code: "medium-1x",
+		title: "Medium 1x",
+		cpu: 1,
+		memory: 2,
+		centsPerVCpuSecond,
+		centsPerGbRamSecond
+	}),
+	"medium-2x": machineDefinition({
+		code: "medium-2x",
+		title: "Medium 2x",
+		cpu: 2,
+		memory: 4,
+		centsPerVCpuSecond,
+		centsPerGbRamSecond
+	}),
+	"large-1x": machineDefinition({
+		code: "large-1x",
+		title: "Large 1x",
+		cpu: 4,
+		memory: 8,
+		centsPerVCpuSecond,
+		centsPerGbRamSecond
+	}),
+	"large-2x": machineDefinition({
+		code: "large-2x",
+		title: "Large 2x",
+		cpu: 8,
+		memory: 16,
+		centsPerVCpuSecond,
+		centsPerGbRamSecond
+	})
 };
-var defaultMachine = "small-1x";
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AddOn,
-  AddOnDefinition,
-  AddOns,
-  ApplyPromoCodeBodySchema,
-  ApplyPromoCodeResult,
-  BillingAlertsResult,
-  BillingClient,
-  BillingLimitActiveOrg,
-  BillingLimitConfiguredCustom,
-  BillingLimitConfiguredNone,
-  BillingLimitConfiguredPlan,
-  BillingLimitPendingResolveOrg,
-  BillingLimitResult,
-  BillingLimitState,
-  BillingLimitUnconfigured,
-  BillingLimitsActiveResult,
-  BillingLimitsPendingResolvesResult,
-  CreatePrivateLinkConnectionBody,
-  CurrentPlan,
-  CustomerPortalRequestBodySchema,
-  CustomerPortalSchema,
-  DeletePrivateLinkResult,
-  EnqueueBuildRequestSchema,
-  EnqueueBuildResponseSchema,
-  ErrorSchema,
-  FreeConnectRequiredSchema,
-  FreeConnectedSchema,
-  MAX_INVOCATION_COST_IN_CENTS,
-  PlanDefinitionSchema,
-  Plans,
-  PlansResult,
-  PrivateLinkConnection,
-  PrivateLinkConnectionList,
-  PrivateLinkConnectionStatus,
-  PrivateLinkRegionsResult,
-  PromoCreditsResult,
-  RegistryCredentialsResponseSchema,
-  ReportComputeUsageEvent,
-  ReportInvocationUsageEvent,
-  ReportInvocationUsageResult,
-  ReportUsagePlan,
-  ReportUsageResult,
-  ResolveBillingLimitRequest,
-  SetAddOnBody,
-  SetAddOnResult,
-  SetPlanBodySchema,
-  SubscribeResultSchema,
-  SubscriptionResult,
-  TriggerInitialDeploymentRequestSchema,
-  TriggerInitialDeploymentResponseSchema,
-  UpdateBillingAlertsRequest,
-  UpdateBillingLimitRequest,
-  UsageParams,
-  UsageResult,
-  UsageSeriesParams,
-  UsageSeriesResult,
-  ValidatePromoCodeBodySchema,
-  ValidatePromoCodeResult,
-  defaultMachine,
-  machineDefinition,
-  machines,
-  objectToSearchParams
-});
+const defaultMachine = "small-1x";
+//#endregion
+exports.AddOn = AddOn;
+exports.AddOnDefinition = AddOnDefinition;
+exports.AddOns = AddOns;
+exports.ApplyPromoCodeBodySchema = ApplyPromoCodeBodySchema;
+exports.ApplyPromoCodeResult = ApplyPromoCodeResult;
+exports.BillingAlertsResult = BillingAlertsResult;
+exports.BillingClient = BillingClient;
+exports.BillingLimitActiveOrg = BillingLimitActiveOrg;
+exports.BillingLimitConfiguredCustom = BillingLimitConfiguredCustom;
+exports.BillingLimitConfiguredNone = BillingLimitConfiguredNone;
+exports.BillingLimitConfiguredPlan = BillingLimitConfiguredPlan;
+exports.BillingLimitPendingResolveOrg = BillingLimitPendingResolveOrg;
+exports.BillingLimitResult = BillingLimitResult;
+exports.BillingLimitState = BillingLimitState;
+exports.BillingLimitUnconfigured = BillingLimitUnconfigured;
+exports.BillingLimitsActiveResult = BillingLimitsActiveResult;
+exports.BillingLimitsPendingResolvesResult = BillingLimitsPendingResolvesResult;
+exports.CancelSubscriptionResponse = CancelSubscriptionResponse;
+exports.CreatePrivateLinkConnectionBody = CreatePrivateLinkConnectionBody;
+exports.CurrentPlan = CurrentPlan;
+exports.CustomerPortalRequestBodySchema = CustomerPortalRequestBodySchema;
+exports.CustomerPortalSchema = CustomerPortalSchema;
+exports.DeletePrivateLinkResult = DeletePrivateLinkResult;
+exports.EnqueueBuildErrorCodeSchema = EnqueueBuildErrorCodeSchema;
+exports.EnqueueBuildRequestSchema = EnqueueBuildRequestSchema;
+exports.EnqueueBuildResponseSchema = EnqueueBuildResponseSchema;
+exports.ErrorSchema = ErrorSchema;
+exports.FreeConnectRequiredSchema = FreeConnectRequiredSchema;
+exports.FreeConnectedSchema = FreeConnectedSchema;
+exports.MAX_INVOCATION_COST_IN_CENTS = MAX_INVOCATION_COST_IN_CENTS;
+exports.PlanDefinitionSchema = PlanDefinitionSchema;
+exports.Plans = Plans;
+exports.PlansResult = PlansResult;
+exports.PrivateLinkConnection = PrivateLinkConnection;
+exports.PrivateLinkConnectionList = PrivateLinkConnectionList;
+exports.PrivateLinkConnectionStatus = PrivateLinkConnectionStatus;
+exports.PrivateLinkRegionsResult = PrivateLinkRegionsResult;
+exports.PromoCreditsResult = PromoCreditsResult;
+exports.RegistryCredentialsResponseSchema = RegistryCredentialsResponseSchema;
+exports.ReportComputeUsageEvent = ReportComputeUsageEvent;
+exports.ReportInvocationUsageEvent = ReportInvocationUsageEvent;
+exports.ReportInvocationUsageResult = ReportInvocationUsageResult;
+exports.ReportUsagePlan = ReportUsagePlan;
+exports.ReportUsageResult = ReportUsageResult;
+exports.ResolveBillingLimitRequest = ResolveBillingLimitRequest;
+exports.SetAddOnBody = SetAddOnBody;
+exports.SetAddOnResult = SetAddOnResult;
+exports.SetPlanBodySchema = SetPlanBodySchema;
+exports.SubscribeResultSchema = SubscribeResultSchema;
+exports.SubscriptionResult = SubscriptionResult;
+exports.TriggerInitialDeploymentRequestSchema = TriggerInitialDeploymentRequestSchema;
+exports.TriggerInitialDeploymentResponseSchema = TriggerInitialDeploymentResponseSchema;
+exports.UpdateBillingAlertsRequest = UpdateBillingAlertsRequest;
+exports.UpdateBillingLimitRequest = UpdateBillingLimitRequest;
+exports.UsageParams = UsageParams;
+exports.UsageResult = UsageResult;
+exports.UsageSeriesParams = UsageSeriesParams;
+exports.UsageSeriesResult = UsageSeriesResult;
+exports.ValidatePromoCodeBodySchema = ValidatePromoCodeBodySchema;
+exports.ValidatePromoCodeResult = ValidatePromoCodeResult;
+exports.defaultMachine = defaultMachine;
+exports.machineDefinition = machineDefinition;
+exports.machines = machines;
+exports.objectToSearchParams = objectToSearchParams;
+
 //# sourceMappingURL=index.cjs.map