autumn-js 1.2.35 → 1.2.37

package/dist/better-auth/index.js

@@ -125,6 +125,17 @@ var attachAddItemTierSchema = import_v42.z.object({
   amount: import_v42.z.union([import_v42.z.number(), import_v42.z.undefined()]).optional(),
   flatAmount: import_v42.z.union([import_v42.z.number(), import_v42.z.undefined()]).optional()
 });
+var attachPropertiesSchema = import_v42.z.union([
+  import_v42.z.string(),
+  import_v42.z.number(),
+  import_v42.z.boolean()
+]);
+var attachFilterSchema = import_v42.z.object({
+  properties: import_v42.z.record(
+    import_v42.z.string(),
+    import_v42.z.union([import_v42.z.string(), import_v42.z.number(), import_v42.z.boolean()])
+  )
+});
 var attachOverageAllowedSchema = import_v42.z.object({
   featureId: import_v42.z.string(),
   enabled: import_v42.z.union([import_v42.z.boolean(), import_v42.z.undefined()]).optional()
@@ -280,13 +291,26 @@ var attachSpendLimitOutboundSchema = import_v42.z.object({
   feature_id: import_v42.z.union([import_v42.z.string(), import_v42.z.undefined()]).optional(),
   enabled: import_v42.z.boolean(),
   limit_type: import_v42.z.union([import_v42.z.string(), import_v42.z.undefined()]).optional(),
-  overage_limit: import_v42.z.union([import_v42.z.number(), import_v42.z.undefined()]).optional()
+  overage_limit: import_v42.z.union([import_v42.z.number(), import_v42.z.undefined()]).optional(),
+  skip_overage_billing: import_v42.z.union([import_v42.z.boolean(), import_v42.z.undefined()]).optional()
+});
+var attachPropertiesOutboundSchema = import_v42.z.union([
+  import_v42.z.string(),
+  import_v42.z.number(),
+  import_v42.z.boolean()
+]);
+var attachFilterOutboundSchema = import_v42.z.object({
+  properties: import_v42.z.record(
+    import_v42.z.string(),
+    import_v42.z.union([import_v42.z.string(), import_v42.z.number(), import_v42.z.boolean()])
+  )
 });
 var attachUsageLimitOutboundSchema = import_v42.z.object({
   feature_id: import_v42.z.string(),
   enabled: import_v42.z.boolean(),
   limit: import_v42.z.number(),
-  interval: import_v42.z.string()
+  interval: import_v42.z.string(),
+  filter: import_v42.z.union([attachFilterOutboundSchema, import_v42.z.undefined()]).optional()
 });
 var attachUsageAlertOutboundSchema = import_v42.z.object({
   feature_id: import_v42.z.union([import_v42.z.string(), import_v42.z.undefined()]).optional(),
@@ -498,14 +522,16 @@ var attachSpendLimitSchema = import_v42.z.object({
   featureId: import_v42.z.union([import_v42.z.string(), import_v42.z.undefined()]).optional(),
   enabled: import_v42.z.union([import_v42.z.boolean(), import_v42.z.undefined()]).optional(),
   limitType: import_v42.z.union([attachLimitTypeSchema, import_v42.z.undefined()]).optional(),
-  overageLimit: import_v42.z.union([import_v42.z.number(), import_v42.z.undefined()]).optional()
+  overageLimit: import_v42.z.union([import_v42.z.number(), import_v42.z.undefined()]).optional(),
+  skipOverageBilling: import_v42.z.union([import_v42.z.boolean(), import_v42.z.undefined()]).optional()
 });
 var attachUsageLimitIntervalSchema = closedEnumSchema2;
 var attachUsageLimitSchema = import_v42.z.object({
   featureId: import_v42.z.string(),
   enabled: import_v42.z.union([import_v42.z.boolean(), import_v42.z.undefined()]).optional(),
   limit: import_v42.z.number(),
-  interval: attachUsageLimitIntervalSchema
+  interval: attachUsageLimitIntervalSchema,
+  filter: import_v42.z.union([attachFilterSchema, import_v42.z.undefined()]).optional()
 });
 var attachThresholdTypeSchema = closedEnumSchema2;
 var attachUsageAlertSchema = import_v42.z.object({
@@ -599,6 +625,17 @@ var import_v44 = require("zod/v4");
 var getOrCreateCustomerGlobalsSchema = import_v44.z.object({
   xApiVersion: import_v44.z.union([import_v44.z.string(), import_v44.z.undefined()]).optional()
 });
+var getOrCreateCustomerPropertiesSchema = import_v44.z.union([
+  import_v44.z.string(),
+  import_v44.z.number(),
+  import_v44.z.boolean()
+]);
+var getOrCreateCustomerFilterSchema = import_v44.z.object({
+  properties: import_v44.z.record(
+    import_v44.z.string(),
+    import_v44.z.union([import_v44.z.string(), import_v44.z.number(), import_v44.z.boolean()])
+  )
+});
 var getOrCreateCustomerOverageAllowedSchema = import_v44.z.object({
   featureId: import_v44.z.string(),
   enabled: import_v44.z.union([import_v44.z.boolean(), import_v44.z.undefined()]).optional()
@@ -624,13 +661,26 @@ var getOrCreateCustomerSpendLimitOutboundSchema = import_v44.z.object({
   feature_id: import_v44.z.union([import_v44.z.string(), import_v44.z.undefined()]).optional(),
   enabled: import_v44.z.boolean(),
   limit_type: import_v44.z.union([import_v44.z.string(), import_v44.z.undefined()]).optional(),
-  overage_limit: import_v44.z.union([import_v44.z.number(), import_v44.z.undefined()]).optional()
+  overage_limit: import_v44.z.union([import_v44.z.number(), import_v44.z.undefined()]).optional(),
+  skip_overage_billing: import_v44.z.union([import_v44.z.boolean(), import_v44.z.undefined()]).optional()
+});
+var getOrCreateCustomerPropertiesOutboundSchema = import_v44.z.union([
+  import_v44.z.string(),
+  import_v44.z.number(),
+  import_v44.z.boolean()
+]);
+var getOrCreateCustomerFilterOutboundSchema = import_v44.z.object({
+  properties: import_v44.z.record(
+    import_v44.z.string(),
+    import_v44.z.union([import_v44.z.string(), import_v44.z.number(), import_v44.z.boolean()])
+  )
 });
 var getOrCreateCustomerUsageLimitOutboundSchema = import_v44.z.object({
   feature_id: import_v44.z.string(),
   enabled: import_v44.z.boolean(),
   limit: import_v44.z.number(),
-  interval: import_v44.z.string()
+  interval: import_v44.z.string(),
+  filter: import_v44.z.union([getOrCreateCustomerFilterOutboundSchema, import_v44.z.undefined()]).optional()
 });
 var getOrCreateCustomerUsageAlertOutboundSchema = import_v44.z.object({
   feature_id: import_v44.z.union([import_v44.z.string(), import_v44.z.undefined()]).optional(),
@@ -701,14 +751,16 @@ var getOrCreateCustomerSpendLimitSchema = import_v44.z.object({
   featureId: import_v44.z.union([import_v44.z.string(), import_v44.z.undefined()]).optional(),
   enabled: import_v44.z.union([import_v44.z.boolean(), import_v44.z.undefined()]).optional(),
   limitType: import_v44.z.union([getOrCreateCustomerLimitTypeSchema, import_v44.z.undefined()]).optional(),
-  overageLimit: import_v44.z.union([import_v44.z.number(), import_v44.z.undefined()]).optional()
+  overageLimit: import_v44.z.union([import_v44.z.number(), import_v44.z.undefined()]).optional(),
+  skipOverageBilling: import_v44.z.union([import_v44.z.boolean(), import_v44.z.undefined()]).optional()
 });
 var getOrCreateCustomerUsageLimitIntervalSchema = closedEnumSchema3;
 var getOrCreateCustomerUsageLimitSchema = import_v44.z.object({
   featureId: import_v44.z.string(),
   enabled: import_v44.z.union([import_v44.z.boolean(), import_v44.z.undefined()]).optional(),
   limit: import_v44.z.number(),
-  interval: getOrCreateCustomerUsageLimitIntervalSchema
+  interval: getOrCreateCustomerUsageLimitIntervalSchema,
+  filter: import_v44.z.union([getOrCreateCustomerFilterSchema, import_v44.z.undefined()]).optional()
 });
 var getOrCreateCustomerThresholdTypeSchema = closedEnumSchema3;
 var getOrCreateCustomerUsageAlertSchema = import_v44.z.object({
@@ -847,6 +899,9 @@ var listPlansVariantDetailsTierSchema = import_v46.z.object({
   amount: import_v46.z.number(),
   flatAmount: import_v46.z.union([import_v46.z.number(), import_v46.z.undefined()]).optional()
 });
+var listPlansVariantDetailsFilterSchema = import_v46.z.object({
+  properties: import_v46.z.record(import_v46.z.string(), import_v46.z.any())
+});
 var listPlansVariantDetailsOverageAllowedSchema = import_v46.z.object({
   featureId: import_v46.z.string(),
   enabled: import_v46.z.boolean()
@@ -854,6 +909,9 @@ var listPlansVariantDetailsOverageAllowedSchema = import_v46.z.object({
 var listPlansConfigSchema = import_v46.z.object({
   ignorePastDue: import_v46.z.boolean()
 });
+var listPlansFilterSchema = import_v46.z.object({
+  properties: import_v46.z.record(import_v46.z.string(), import_v46.z.any())
+});
 var listPlansOverageAllowedSchema = import_v46.z.object({
   featureId: import_v46.z.string(),
   enabled: import_v46.z.boolean()
@@ -1015,14 +1073,16 @@ var listPlansVariantDetailsSpendLimitSchema = import_v46.z.object({
   featureId: import_v46.z.union([import_v46.z.string(), import_v46.z.undefined()]).optional(),
   enabled: import_v46.z.boolean(),
   limitType: import_v46.z.union([listPlansVariantDetailsLimitTypeSchema, import_v46.z.undefined()]).optional(),
-  overageLimit: import_v46.z.union([import_v46.z.number(), import_v46.z.undefined()]).optional()
+  overageLimit: import_v46.z.union([import_v46.z.number(), import_v46.z.undefined()]).optional(),
+  skipOverageBilling: import_v46.z.union([import_v46.z.boolean(), import_v46.z.undefined()]).optional()
 });
 var listPlansVariantDetailsUsageLimitIntervalSchema = openEnumSchema3;
 var listPlansVariantDetailsUsageLimitSchema = import_v46.z.object({
   featureId: import_v46.z.string(),
   enabled: import_v46.z.boolean(),
   limit: import_v46.z.number(),
-  interval: listPlansVariantDetailsUsageLimitIntervalSchema
+  interval: listPlansVariantDetailsUsageLimitIntervalSchema,
+  filter: import_v46.z.union([listPlansVariantDetailsFilterSchema, import_v46.z.undefined()]).optional()
 });
 var listPlansVariantDetailsThresholdTypeSchema = openEnumSchema3;
 var listPlansVariantDetailsUsageAlertSchema = import_v46.z.object({
@@ -1072,14 +1132,16 @@ var listPlansSpendLimitSchema = import_v46.z.object({
   featureId: import_v46.z.union([import_v46.z.string(), import_v46.z.undefined()]).optional(),
   enabled: import_v46.z.boolean(),
   limitType: import_v46.z.union([listPlansLimitTypeSchema, import_v46.z.undefined()]).optional(),
-  overageLimit: import_v46.z.union([import_v46.z.number(), import_v46.z.undefined()]).optional()
+  overageLimit: import_v46.z.union([import_v46.z.number(), import_v46.z.undefined()]).optional(),
+  skipOverageBilling: import_v46.z.union([import_v46.z.boolean(), import_v46.z.undefined()]).optional()
 });
 var listPlansUsageLimitIntervalSchema = openEnumSchema3;
 var listPlansUsageLimitSchema = import_v46.z.object({
   featureId: import_v46.z.string(),
   enabled: import_v46.z.boolean(),
   limit: import_v46.z.number(),
-  interval: listPlansUsageLimitIntervalSchema
+  interval: listPlansUsageLimitIntervalSchema,
+  filter: import_v46.z.union([listPlansFilterSchema, import_v46.z.undefined()]).optional()
 });
 var listPlansThresholdTypeSchema = openEnumSchema3;
 var listPlansUsageAlertSchema = import_v46.z.object({
@@ -1157,6 +1219,17 @@ var multiAttachAttachDiscountSchema = import_v47.z.object({
   rewardId: import_v47.z.union([import_v47.z.string(), import_v47.z.undefined()]).optional(),
   promotionCode: import_v47.z.union([import_v47.z.string(), import_v47.z.undefined()]).optional()
 });
+var multiAttachPropertiesSchema = import_v47.z.union([
+  import_v47.z.string(),
+  import_v47.z.number(),
+  import_v47.z.boolean()
+]);
+var multiAttachFilterSchema = import_v47.z.object({
+  properties: import_v47.z.record(
+    import_v47.z.string(),
+    import_v47.z.union([import_v47.z.string(), import_v47.z.number(), import_v47.z.boolean()])
+  )
+});
 var multiAttachOverageAllowedSchema = import_v47.z.object({
   featureId: import_v47.z.string(),
   enabled: import_v47.z.union([import_v47.z.boolean(), import_v47.z.undefined()]).optional()
@@ -1249,13 +1322,26 @@ var multiAttachSpendLimitOutboundSchema = import_v47.z.object({
   feature_id: import_v47.z.union([import_v47.z.string(), import_v47.z.undefined()]).optional(),
   enabled: import_v47.z.boolean(),
   limit_type: import_v47.z.union([import_v47.z.string(), import_v47.z.undefined()]).optional(),
-  overage_limit: import_v47.z.union([import_v47.z.number(), import_v47.z.undefined()]).optional()
+  overage_limit: import_v47.z.union([import_v47.z.number(), import_v47.z.undefined()]).optional(),
+  skip_overage_billing: import_v47.z.union([import_v47.z.boolean(), import_v47.z.undefined()]).optional()
+});
+var multiAttachPropertiesOutboundSchema = import_v47.z.union([
+  import_v47.z.string(),
+  import_v47.z.number(),
+  import_v47.z.boolean()
+]);
+var multiAttachFilterOutboundSchema = import_v47.z.object({
+  properties: import_v47.z.record(
+    import_v47.z.string(),
+    import_v47.z.union([import_v47.z.string(), import_v47.z.number(), import_v47.z.boolean()])
+  )
 });
 var multiAttachUsageLimitOutboundSchema = import_v47.z.object({
   feature_id: import_v47.z.string(),
   enabled: import_v47.z.boolean(),
   limit: import_v47.z.number(),
-  interval: import_v47.z.string()
+  interval: import_v47.z.string(),
+  filter: import_v47.z.union([multiAttachFilterOutboundSchema, import_v47.z.undefined()]).optional()
 });
 var multiAttachUsageAlertOutboundSchema = import_v47.z.object({
   feature_id: import_v47.z.union([import_v47.z.string(), import_v47.z.undefined()]).optional(),
@@ -1354,14 +1440,16 @@ var multiAttachSpendLimitSchema = import_v47.z.object({
   featureId: import_v47.z.union([import_v47.z.string(), import_v47.z.undefined()]).optional(),
   enabled: import_v47.z.union([import_v47.z.boolean(), import_v47.z.undefined()]).optional(),
   limitType: import_v47.z.union([multiAttachLimitTypeSchema, import_v47.z.undefined()]).optional(),
-  overageLimit: import_v47.z.union([import_v47.z.number(), import_v47.z.undefined()]).optional()
+  overageLimit: import_v47.z.union([import_v47.z.number(), import_v47.z.undefined()]).optional(),
+  skipOverageBilling: import_v47.z.union([import_v47.z.boolean(), import_v47.z.undefined()]).optional()
 });
 var multiAttachEntityDataIntervalSchema = closedEnumSchema4;
 var multiAttachUsageLimitSchema = import_v47.z.object({
   featureId: import_v47.z.string(),
   enabled: import_v47.z.union([import_v47.z.boolean(), import_v47.z.undefined()]).optional(),
   limit: import_v47.z.number(),
-  interval: multiAttachEntityDataIntervalSchema
+  interval: multiAttachEntityDataIntervalSchema,
+  filter: import_v47.z.union([multiAttachFilterSchema, import_v47.z.undefined()]).optional()
 });
 var multiAttachThresholdTypeSchema = closedEnumSchema4;
 var multiAttachUsageAlertSchema = import_v47.z.object({
@@ -1467,6 +1555,17 @@ var previewAttachAddItemTierSchema = import_v49.z.object({
   amount: import_v49.z.union([import_v49.z.number(), import_v49.z.undefined()]).optional(),
   flatAmount: import_v49.z.union([import_v49.z.number(), import_v49.z.undefined()]).optional()
 });
+var previewAttachPropertiesSchema = import_v49.z.union([
+  import_v49.z.string(),
+  import_v49.z.number(),
+  import_v49.z.boolean()
+]);
+var previewAttachFilterSchema = import_v49.z.object({
+  properties: import_v49.z.record(
+    import_v49.z.string(),
+    import_v49.z.union([import_v49.z.string(), import_v49.z.number(), import_v49.z.boolean()])
+  )
+});
 var previewAttachOverageAllowedSchema = import_v49.z.object({
   featureId: import_v49.z.string(),
   enabled: import_v49.z.union([import_v49.z.boolean(), import_v49.z.undefined()]).optional()
@@ -1692,13 +1791,26 @@ var previewAttachSpendLimitOutboundSchema = import_v49.z.object({
   feature_id: import_v49.z.union([import_v49.z.string(), import_v49.z.undefined()]).optional(),
   enabled: import_v49.z.boolean(),
   limit_type: import_v49.z.union([import_v49.z.string(), import_v49.z.undefined()]).optional(),
-  overage_limit: import_v49.z.union([import_v49.z.number(), import_v49.z.undefined()]).optional()
+  overage_limit: import_v49.z.union([import_v49.z.number(), import_v49.z.undefined()]).optional(),
+  skip_overage_billing: import_v49.z.union([import_v49.z.boolean(), import_v49.z.undefined()]).optional()
+});
+var previewAttachPropertiesOutboundSchema = import_v49.z.union([
+  import_v49.z.string(),
+  import_v49.z.number(),
+  import_v49.z.boolean()
+]);
+var previewAttachFilterOutboundSchema = import_v49.z.object({
+  properties: import_v49.z.record(
+    import_v49.z.string(),
+    import_v49.z.union([import_v49.z.string(), import_v49.z.number(), import_v49.z.boolean()])
+  )
 });
 var previewAttachUsageLimitOutboundSchema = import_v49.z.object({
   feature_id: import_v49.z.string(),
   enabled: import_v49.z.boolean(),
   limit: import_v49.z.number(),
-  interval: import_v49.z.string()
+  interval: import_v49.z.string(),
+  filter: import_v49.z.union([previewAttachFilterOutboundSchema, import_v49.z.undefined()]).optional()
 });
 var previewAttachUsageAlertOutboundSchema = import_v49.z.object({
   feature_id: import_v49.z.union([import_v49.z.string(), import_v49.z.undefined()]).optional(),
@@ -1914,14 +2026,16 @@ var previewAttachSpendLimitSchema = import_v49.z.object({
   featureId: import_v49.z.union([import_v49.z.string(), import_v49.z.undefined()]).optional(),
   enabled: import_v49.z.union([import_v49.z.boolean(), import_v49.z.undefined()]).optional(),
   limitType: import_v49.z.union([previewAttachLimitTypeSchema, import_v49.z.undefined()]).optional(),
-  overageLimit: import_v49.z.union([import_v49.z.number(), import_v49.z.undefined()]).optional()
+  overageLimit: import_v49.z.union([import_v49.z.number(), import_v49.z.undefined()]).optional(),
+  skipOverageBilling: import_v49.z.union([import_v49.z.boolean(), import_v49.z.undefined()]).optional()
 });
 var previewAttachUsageLimitIntervalSchema = closedEnumSchema5;
 var previewAttachUsageLimitSchema = import_v49.z.object({
   featureId: import_v49.z.string(),
   enabled: import_v49.z.union([import_v49.z.boolean(), import_v49.z.undefined()]).optional(),
   limit: import_v49.z.number(),
-  interval: previewAttachUsageLimitIntervalSchema
+  interval: previewAttachUsageLimitIntervalSchema,
+  filter: import_v49.z.union([previewAttachFilterSchema, import_v49.z.undefined()]).optional()
 });
 var previewAttachThresholdTypeSchema = closedEnumSchema5;
 var previewAttachUsageAlertSchema = import_v49.z.object({
@@ -2046,6 +2160,17 @@ var previewMultiAttachAttachDiscountSchema = import_v410.z.object({
   rewardId: import_v410.z.union([import_v410.z.string(), import_v410.z.undefined()]).optional(),
   promotionCode: import_v410.z.union([import_v410.z.string(), import_v410.z.undefined()]).optional()
 });
+var previewMultiAttachPropertiesSchema = import_v410.z.union([
+  import_v410.z.string(),
+  import_v410.z.number(),
+  import_v410.z.boolean()
+]);
+var previewMultiAttachFilterSchema = import_v410.z.object({
+  properties: import_v410.z.record(
+    import_v410.z.string(),
+    import_v410.z.union([import_v410.z.string(), import_v410.z.number(), import_v410.z.boolean()])
+  )
+});
 var previewMultiAttachOverageAllowedSchema = import_v410.z.object({
   featureId: import_v410.z.string(),
   enabled: import_v410.z.union([import_v410.z.boolean(), import_v410.z.undefined()]).optional()
@@ -2208,13 +2333,26 @@ var previewMultiAttachSpendLimitOutboundSchema = import_v410.z.object({
   feature_id: import_v410.z.union([import_v410.z.string(), import_v410.z.undefined()]).optional(),
   enabled: import_v410.z.boolean(),
   limit_type: import_v410.z.union([import_v410.z.string(), import_v410.z.undefined()]).optional(),
-  overage_limit: import_v410.z.union([import_v410.z.number(), import_v410.z.undefined()]).optional()
+  overage_limit: import_v410.z.union([import_v410.z.number(), import_v410.z.undefined()]).optional(),
+  skip_overage_billing: import_v410.z.union([import_v410.z.boolean(), import_v410.z.undefined()]).optional()
+});
+var previewMultiAttachPropertiesOutboundSchema = import_v410.z.union([
+  import_v410.z.string(),
+  import_v410.z.number(),
+  import_v410.z.boolean()
+]);
+var previewMultiAttachFilterOutboundSchema = import_v410.z.object({
+  properties: import_v410.z.record(
+    import_v410.z.string(),
+    import_v410.z.union([import_v410.z.string(), import_v410.z.number(), import_v410.z.boolean()])
+  )
 });
 var previewMultiAttachUsageLimitOutboundSchema = import_v410.z.object({
   feature_id: import_v410.z.string(),
   enabled: import_v410.z.boolean(),
   limit: import_v410.z.number(),
-  interval: import_v410.z.string()
+  interval: import_v410.z.string(),
+  filter: import_v410.z.union([previewMultiAttachFilterOutboundSchema, import_v410.z.undefined()]).optional()
 });
 var previewMultiAttachUsageAlertOutboundSchema = import_v410.z.object({
   feature_id: import_v410.z.union([import_v410.z.string(), import_v410.z.undefined()]).optional(),
@@ -2320,14 +2458,16 @@ var previewMultiAttachSpendLimitSchema = import_v410.z.object({
   featureId: import_v410.z.union([import_v410.z.string(), import_v410.z.undefined()]).optional(),
   enabled: import_v410.z.union([import_v410.z.boolean(), import_v410.z.undefined()]).optional(),
   limitType: import_v410.z.union([previewMultiAttachLimitTypeSchema, import_v410.z.undefined()]).optional(),
-  overageLimit: import_v410.z.union([import_v410.z.number(), import_v410.z.undefined()]).optional()
+  overageLimit: import_v410.z.union([import_v410.z.number(), import_v410.z.undefined()]).optional(),
+  skipOverageBilling: import_v410.z.union([import_v410.z.boolean(), import_v410.z.undefined()]).optional()
 });
 var previewMultiAttachEntityDataIntervalSchema = closedEnumSchema6;
 var previewMultiAttachUsageLimitSchema = import_v410.z.object({
   featureId: import_v410.z.string(),
   enabled: import_v410.z.union([import_v410.z.boolean(), import_v410.z.undefined()]).optional(),
   limit: import_v410.z.number(),
-  interval: previewMultiAttachEntityDataIntervalSchema
+  interval: previewMultiAttachEntityDataIntervalSchema,
+  filter: import_v410.z.union([previewMultiAttachFilterSchema, import_v410.z.undefined()]).optional()
 });
 var previewMultiAttachThresholdTypeSchema = closedEnumSchema6;
 var previewMultiAttachUsageAlertSchema = import_v410.z.object({
@@ -2444,6 +2584,17 @@ var previewUpdateAddItemTierSchema = import_v411.z.object({
   amount: import_v411.z.union([import_v411.z.number(), import_v411.z.undefined()]).optional(),
   flatAmount: import_v411.z.union([import_v411.z.number(), import_v411.z.undefined()]).optional()
 });
+var previewUpdatePropertiesSchema = import_v411.z.union([
+  import_v411.z.string(),
+  import_v411.z.number(),
+  import_v411.z.boolean()
+]);
+var previewUpdateFilterSchema = import_v411.z.object({
+  properties: import_v411.z.record(
+    import_v411.z.string(),
+    import_v411.z.union([import_v411.z.string(), import_v411.z.number(), import_v411.z.boolean()])
+  )
+});
 var previewUpdateOverageAllowedSchema = import_v411.z.object({
   featureId: import_v411.z.string(),
   enabled: import_v411.z.union([import_v411.z.boolean(), import_v411.z.undefined()]).optional()
@@ -2664,13 +2815,26 @@ var previewUpdateSpendLimitOutboundSchema = import_v411.z.object({
   feature_id: import_v411.z.union([import_v411.z.string(), import_v411.z.undefined()]).optional(),
   enabled: import_v411.z.boolean(),
   limit_type: import_v411.z.union([import_v411.z.string(), import_v411.z.undefined()]).optional(),
-  overage_limit: import_v411.z.union([import_v411.z.number(), import_v411.z.undefined()]).optional()
+  overage_limit: import_v411.z.union([import_v411.z.number(), import_v411.z.undefined()]).optional(),
+  skip_overage_billing: import_v411.z.union([import_v411.z.boolean(), import_v411.z.undefined()]).optional()
+});
+var previewUpdatePropertiesOutboundSchema = import_v411.z.union([
+  import_v411.z.string(),
+  import_v411.z.number(),
+  import_v411.z.boolean()
+]);
+var previewUpdateFilterOutboundSchema = import_v411.z.object({
+  properties: import_v411.z.record(
+    import_v411.z.string(),
+    import_v411.z.union([import_v411.z.string(), import_v411.z.number(), import_v411.z.boolean()])
+  )
 });
 var previewUpdateUsageLimitOutboundSchema = import_v411.z.object({
   feature_id: import_v411.z.string(),
   enabled: import_v411.z.boolean(),
   limit: import_v411.z.number(),
-  interval: import_v411.z.string()
+  interval: import_v411.z.string(),
+  filter: import_v411.z.union([previewUpdateFilterOutboundSchema, import_v411.z.undefined()]).optional()
 });
 var previewUpdateUsageAlertOutboundSchema = import_v411.z.object({
   feature_id: import_v411.z.union([import_v411.z.string(), import_v411.z.undefined()]).optional(),
@@ -2734,6 +2898,7 @@ var previewUpdateParamsOutboundSchema = import_v411.z.object({
   cancel_action: import_v411.z.union([import_v411.z.string(), import_v411.z.undefined()]).optional(),
   billing_cycle_anchor: import_v411.z.union([import_v411.z.literal("now"), import_v411.z.undefined()]).optional(),
   no_billing_changes: import_v411.z.union([import_v411.z.boolean(), import_v411.z.undefined()]).optional(),
+  refund_last_payment: import_v411.z.union([import_v411.z.string(), import_v411.z.undefined()]).optional(),
   recalculate_balances: import_v411.z.union([previewUpdateRecalculateBalancesOutboundSchema, import_v411.z.undefined()]).optional(),
   carry_over_usages: import_v411.z.union([previewUpdateCarryOverUsagesOutboundSchema, import_v411.z.undefined()]).optional()
 });
@@ -2870,14 +3035,16 @@ var previewUpdateSpendLimitSchema = import_v411.z.object({
   featureId: import_v411.z.union([import_v411.z.string(), import_v411.z.undefined()]).optional(),
   enabled: import_v411.z.union([import_v411.z.boolean(), import_v411.z.undefined()]).optional(),
   limitType: import_v411.z.union([previewUpdateLimitTypeSchema, import_v411.z.undefined()]).optional(),
-  overageLimit: import_v411.z.union([import_v411.z.number(), import_v411.z.undefined()]).optional()
+  overageLimit: import_v411.z.union([import_v411.z.number(), import_v411.z.undefined()]).optional(),
+  skipOverageBilling: import_v411.z.union([import_v411.z.boolean(), import_v411.z.undefined()]).optional()
 });
 var previewUpdateUsageLimitIntervalSchema = closedEnumSchema7;
 var previewUpdateUsageLimitSchema = import_v411.z.object({
   featureId: import_v411.z.string(),
   enabled: import_v411.z.union([import_v411.z.boolean(), import_v411.z.undefined()]).optional(),
   limit: import_v411.z.number(),
-  interval: previewUpdateUsageLimitIntervalSchema
+  interval: previewUpdateUsageLimitIntervalSchema,
+  filter: import_v411.z.union([previewUpdateFilterSchema, import_v411.z.undefined()]).optional()
 });
 var previewUpdateThresholdTypeSchema = closedEnumSchema7;
 var previewUpdateUsageAlertSchema = import_v411.z.object({
@@ -2905,6 +3072,7 @@ var previewUpdateCustomizeSchema = import_v411.z.object({
 var previewUpdateProrationBehaviorSchema = closedEnumSchema7;
 var previewUpdateRedirectModeSchema = closedEnumSchema7;
 var previewUpdateCancelActionSchema = closedEnumSchema7;
+var previewUpdateRefundLastPaymentSchema = closedEnumSchema7;
 var previewUpdateParamsSchema = import_v411.z.object({
   customerId: import_v411.z.string(),
   entityId: import_v411.z.union([import_v411.z.string(), import_v411.z.undefined()]).optional(),
@@ -2920,6 +3088,7 @@ var previewUpdateParamsSchema = import_v411.z.object({
   cancelAction: import_v411.z.union([previewUpdateCancelActionSchema, import_v411.z.undefined()]).optional(),
   billingCycleAnchor: import_v411.z.union([import_v411.z.literal("now"), import_v411.z.undefined()]).optional(),
   noBillingChanges: import_v411.z.union([import_v411.z.boolean(), import_v411.z.undefined()]).optional(),
+  refundLastPayment: import_v411.z.union([previewUpdateRefundLastPaymentSchema, import_v411.z.undefined()]).optional(),
   recalculateBalances: import_v411.z.union([previewUpdateRecalculateBalancesSchema, import_v411.z.undefined()]).optional(),
   carryOverUsages: import_v411.z.union([previewUpdateCarryOverUsagesSchema, import_v411.z.undefined()]).optional()
 });
@@ -3004,6 +3173,17 @@ var setupPaymentAddItemTierSchema = import_v413.z.object({
   amount: import_v413.z.union([import_v413.z.number(), import_v413.z.undefined()]).optional(),
   flatAmount: import_v413.z.union([import_v413.z.number(), import_v413.z.undefined()]).optional()
 });
+var setupPaymentPropertiesSchema = import_v413.z.union([
+  import_v413.z.string(),
+  import_v413.z.number(),
+  import_v413.z.boolean()
+]);
+var setupPaymentFilterSchema = import_v413.z.object({
+  properties: import_v413.z.record(
+    import_v413.z.string(),
+    import_v413.z.union([import_v413.z.string(), import_v413.z.number(), import_v413.z.boolean()])
+  )
+});
 var setupPaymentOverageAllowedSchema = import_v413.z.object({
   featureId: import_v413.z.string(),
   enabled: import_v413.z.union([import_v413.z.boolean(), import_v413.z.undefined()]).optional()
@@ -3156,13 +3336,26 @@ var setupPaymentSpendLimitOutboundSchema = import_v413.z.object({
   feature_id: import_v413.z.union([import_v413.z.string(), import_v413.z.undefined()]).optional(),
   enabled: import_v413.z.boolean(),
   limit_type: import_v413.z.union([import_v413.z.string(), import_v413.z.undefined()]).optional(),
-  overage_limit: import_v413.z.union([import_v413.z.number(), import_v413.z.undefined()]).optional()
+  overage_limit: import_v413.z.union([import_v413.z.number(), import_v413.z.undefined()]).optional(),
+  skip_overage_billing: import_v413.z.union([import_v413.z.boolean(), import_v413.z.undefined()]).optional()
+});
+var setupPaymentPropertiesOutboundSchema = import_v413.z.union([
+  import_v413.z.string(),
+  import_v413.z.number(),
+  import_v413.z.boolean()
+]);
+var setupPaymentFilterOutboundSchema = import_v413.z.object({
+  properties: import_v413.z.record(
+    import_v413.z.string(),
+    import_v413.z.union([import_v413.z.string(), import_v413.z.number(), import_v413.z.boolean()])
+  )
 });
 var setupPaymentUsageLimitOutboundSchema = import_v413.z.object({
   feature_id: import_v413.z.string(),
   enabled: import_v413.z.boolean(),
   limit: import_v413.z.number(),
-  interval: import_v413.z.string()
+  interval: import_v413.z.string(),
+  filter: import_v413.z.union([setupPaymentFilterOutboundSchema, import_v413.z.undefined()]).optional()
 });
 var setupPaymentUsageAlertOutboundSchema = import_v413.z.object({
   feature_id: import_v413.z.union([import_v413.z.string(), import_v413.z.undefined()]).optional(),
@@ -3361,14 +3554,16 @@ var setupPaymentSpendLimitSchema = import_v413.z.object({
   featureId: import_v413.z.union([import_v413.z.string(), import_v413.z.undefined()]).optional(),
   enabled: import_v413.z.union([import_v413.z.boolean(), import_v413.z.undefined()]).optional(),
   limitType: import_v413.z.union([setupPaymentLimitTypeSchema, import_v413.z.undefined()]).optional(),
-  overageLimit: import_v413.z.union([import_v413.z.number(), import_v413.z.undefined()]).optional()
+  overageLimit: import_v413.z.union([import_v413.z.number(), import_v413.z.undefined()]).optional(),
+  skipOverageBilling: import_v413.z.union([import_v413.z.boolean(), import_v413.z.undefined()]).optional()
 });
 var setupPaymentUsageLimitIntervalSchema = closedEnumSchema8;
 var setupPaymentUsageLimitSchema = import_v413.z.object({
   featureId: import_v413.z.string(),
   enabled: import_v413.z.union([import_v413.z.boolean(), import_v413.z.undefined()]).optional(),
   limit: import_v413.z.number(),
-  interval: setupPaymentUsageLimitIntervalSchema
+  interval: setupPaymentUsageLimitIntervalSchema,
+  filter: import_v413.z.union([setupPaymentFilterSchema, import_v413.z.undefined()]).optional()
 });
 var setupPaymentThresholdTypeSchema = closedEnumSchema8;
 var setupPaymentUsageAlertSchema = import_v413.z.object({
@@ -3441,6 +3636,17 @@ var billingUpdateAddItemTierSchema = import_v414.z.object({
   amount: import_v414.z.union([import_v414.z.number(), import_v414.z.undefined()]).optional(),
   flatAmount: import_v414.z.union([import_v414.z.number(), import_v414.z.undefined()]).optional()
 });
+var billingUpdatePropertiesSchema = import_v414.z.union([
+  import_v414.z.string(),
+  import_v414.z.number(),
+  import_v414.z.boolean()
+]);
+var billingUpdateFilterSchema = import_v414.z.object({
+  properties: import_v414.z.record(
+    import_v414.z.string(),
+    import_v414.z.union([import_v414.z.string(), import_v414.z.number(), import_v414.z.boolean()])
+  )
+});
 var billingUpdateOverageAllowedSchema = import_v414.z.object({
   featureId: import_v414.z.string(),
   enabled: import_v414.z.union([import_v414.z.boolean(), import_v414.z.undefined()]).optional()
@@ -3597,13 +3803,26 @@ var billingUpdateSpendLimitOutboundSchema = import_v414.z.object({
   feature_id: import_v414.z.union([import_v414.z.string(), import_v414.z.undefined()]).optional(),
   enabled: import_v414.z.boolean(),
   limit_type: import_v414.z.union([import_v414.z.string(), import_v414.z.undefined()]).optional(),
-  overage_limit: import_v414.z.union([import_v414.z.number(), import_v414.z.undefined()]).optional()
+  overage_limit: import_v414.z.union([import_v414.z.number(), import_v414.z.undefined()]).optional(),
+  skip_overage_billing: import_v414.z.union([import_v414.z.boolean(), import_v414.z.undefined()]).optional()
+});
+var billingUpdatePropertiesOutboundSchema = import_v414.z.union([
+  import_v414.z.string(),
+  import_v414.z.number(),
+  import_v414.z.boolean()
+]);
+var billingUpdateFilterOutboundSchema = import_v414.z.object({
+  properties: import_v414.z.record(
+    import_v414.z.string(),
+    import_v414.z.union([import_v414.z.string(), import_v414.z.number(), import_v414.z.boolean()])
+  )
 });
 var billingUpdateUsageLimitOutboundSchema = import_v414.z.object({
   feature_id: import_v414.z.string(),
   enabled: import_v414.z.boolean(),
   limit: import_v414.z.number(),
-  interval: import_v414.z.string()
+  interval: import_v414.z.string(),
+  filter: import_v414.z.union([billingUpdateFilterOutboundSchema, import_v414.z.undefined()]).optional()
 });
 var billingUpdateUsageAlertOutboundSchema = import_v414.z.object({
   feature_id: import_v414.z.union([import_v414.z.string(), import_v414.z.undefined()]).optional(),
@@ -3664,6 +3883,7 @@ var updateSubscriptionParamsOutboundSchema = import_v414.z.object({
   cancel_action: import_v414.z.union([import_v414.z.string(), import_v414.z.undefined()]).optional(),
   billing_cycle_anchor: import_v414.z.union([import_v414.z.literal("now"), import_v414.z.undefined()]).optional(),
   no_billing_changes: import_v414.z.union([import_v414.z.boolean(), import_v414.z.undefined()]).optional(),
+  refund_last_payment: import_v414.z.union([import_v414.z.string(), import_v414.z.undefined()]).optional(),
   recalculate_balances: import_v414.z.union([billingUpdateRecalculateBalancesOutboundSchema, import_v414.z.undefined()]).optional(),
   carry_over_usages: import_v414.z.union([billingUpdateCarryOverUsagesOutboundSchema, import_v414.z.undefined()]).optional()
 });
@@ -3799,14 +4019,16 @@ var billingUpdateSpendLimitSchema = import_v414.z.object({
   featureId: import_v414.z.union([import_v414.z.string(), import_v414.z.undefined()]).optional(),
   enabled: import_v414.z.union([import_v414.z.boolean(), import_v414.z.undefined()]).optional(),
   limitType: import_v414.z.union([billingUpdateLimitTypeSchema, import_v414.z.undefined()]).optional(),
-  overageLimit: import_v414.z.union([import_v414.z.number(), import_v414.z.undefined()]).optional()
+  overageLimit: import_v414.z.union([import_v414.z.number(), import_v414.z.undefined()]).optional(),
+  skipOverageBilling: import_v414.z.union([import_v414.z.boolean(), import_v414.z.undefined()]).optional()
 });
 var billingUpdateUsageLimitIntervalSchema = closedEnumSchema9;
 var billingUpdateUsageLimitSchema = import_v414.z.object({
   featureId: import_v414.z.string(),
   enabled: import_v414.z.union([import_v414.z.boolean(), import_v414.z.undefined()]).optional(),
   limit: import_v414.z.number(),
-  interval: billingUpdateUsageLimitIntervalSchema
+  interval: billingUpdateUsageLimitIntervalSchema,
+  filter: import_v414.z.union([billingUpdateFilterSchema, import_v414.z.undefined()]).optional()
 });
 var billingUpdateThresholdTypeSchema = closedEnumSchema9;
 var billingUpdateUsageAlertSchema = import_v414.z.object({
@@ -3834,6 +4056,7 @@ var billingUpdateCustomizeSchema = import_v414.z.object({
 var billingUpdateProrationBehaviorSchema = closedEnumSchema9;
 var billingUpdateRedirectModeSchema = closedEnumSchema9;
 var billingUpdateCancelActionSchema = closedEnumSchema9;
+var billingUpdateRefundLastPaymentSchema = closedEnumSchema9;
 var updateSubscriptionParamsSchema = import_v414.z.object({
   customerId: import_v414.z.string(),
   entityId: import_v414.z.union([import_v414.z.string(), import_v414.z.undefined()]).optional(),
@@ -3849,6 +4072,7 @@ var updateSubscriptionParamsSchema = import_v414.z.object({
   cancelAction: import_v414.z.union([billingUpdateCancelActionSchema, import_v414.z.undefined()]).optional(),
   billingCycleAnchor: import_v414.z.union([import_v414.z.literal("now"), import_v414.z.undefined()]).optional(),
   noBillingChanges: import_v414.z.union([import_v414.z.boolean(), import_v414.z.undefined()]).optional(),
+  refundLastPayment: import_v414.z.union([billingUpdateRefundLastPaymentSchema, import_v414.z.undefined()]).optional(),
   recalculateBalances: import_v414.z.union([billingUpdateRecalculateBalancesSchema, import_v414.z.undefined()]).optional(),
   carryOverUsages: import_v414.z.union([billingUpdateCarryOverUsagesSchema, import_v414.z.undefined()]).optional()
 });
@@ -5645,7 +5869,8 @@ var AttachPlanSchedule = {
 var AttachCode = {
   ThreedsRequired: "3ds_required",
   PaymentMethodRequired: "payment_method_required",
-  PaymentFailed: "payment_failed"
+  PaymentFailed: "payment_failed",
+  PaymentProcessing: "payment_processing"
 };
 var AttachFeatureQuantity$outboundSchema = z26.pipe(
   z26.object({
@@ -5943,23 +6168,33 @@ var AttachSpendLimit$outboundSchema = z26.pipe(
     featureId: z26.optional(z26.string()),
     enabled: z26._default(z26.boolean(), false),
     limitType: z26.optional(AttachLimitType$outboundSchema),
-    overageLimit: z26.optional(z26.number())
+    overageLimit: z26.optional(z26.number()),
+    skipOverageBilling: z26.optional(z26.boolean())
   }),
   z26.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
       limitType: "limit_type",
-      overageLimit: "overage_limit"
+      overageLimit: "overage_limit",
+      skipOverageBilling: "skip_overage_billing"
     });
   })
 );
 var AttachUsageLimitInterval$outboundSchema = z26.enum(AttachUsageLimitInterval);
+var AttachProperties$outboundSchema = smartUnion([z26.string(), z26.number(), z26.boolean()]);
+var AttachFilter$outboundSchema = z26.object({
+  properties: z26.record(
+    z26.string(),
+    smartUnion([z26.string(), z26.number(), z26.boolean()])
+  )
+});
 var AttachUsageLimit$outboundSchema = z26.pipe(
   z26.object({
     featureId: z26.string(),
     enabled: z26._default(z26.boolean(), true),
     limit: z26.number(),
-    interval: AttachUsageLimitInterval$outboundSchema
+    interval: AttachUsageLimitInterval$outboundSchema,
+    filter: z26.optional(z26.lazy(() => AttachFilter$outboundSchema))
   }),
   z26.transform((v) => {
     return remap(v, {
@@ -6620,10 +6855,15 @@ var BillingUpdateCancelAction = {
   CancelEndOfCycle: "cancel_end_of_cycle",
   Uncancel: "uncancel"
 };
+var BillingUpdateRefundLastPayment = {
+  Prorated: "prorated",
+  Full: "full"
+};
 var BillingUpdateCode = {
   ThreedsRequired: "3ds_required",
   PaymentMethodRequired: "payment_method_required",
-  PaymentFailed: "payment_failed"
+  PaymentFailed: "payment_failed",
+  PaymentProcessing: "payment_processing"
 };
 var BillingUpdateFeatureQuantity$outboundSchema = z29.pipe(
   z29.object({
@@ -6939,23 +7179,33 @@ var BillingUpdateSpendLimit$outboundSchema = z29.pipe(
     featureId: z29.optional(z29.string()),
     enabled: z29._default(z29.boolean(), false),
     limitType: z29.optional(BillingUpdateLimitType$outboundSchema),
-    overageLimit: z29.optional(z29.number())
+    overageLimit: z29.optional(z29.number()),
+    skipOverageBilling: z29.optional(z29.boolean())
   }),
   z29.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
       limitType: "limit_type",
-      overageLimit: "overage_limit"
+      overageLimit: "overage_limit",
+      skipOverageBilling: "skip_overage_billing"
     });
   })
 );
 var BillingUpdateUsageLimitInterval$outboundSchema = z29.enum(BillingUpdateUsageLimitInterval);
+var BillingUpdateProperties$outboundSchema = smartUnion([z29.string(), z29.number(), z29.boolean()]);
+var BillingUpdateFilter$outboundSchema = z29.object({
+  properties: z29.record(
+    z29.string(),
+    smartUnion([z29.string(), z29.number(), z29.boolean()])
+  )
+});
 var BillingUpdateUsageLimit$outboundSchema = z29.pipe(
   z29.object({
     featureId: z29.string(),
     enabled: z29._default(z29.boolean(), true),
     limit: z29.number(),
-    interval: BillingUpdateUsageLimitInterval$outboundSchema
+    interval: BillingUpdateUsageLimitInterval$outboundSchema,
+    filter: z29.optional(z29.lazy(() => BillingUpdateFilter$outboundSchema))
   }),
   z29.transform((v) => {
     return remap(v, {
@@ -7079,6 +7329,7 @@ var BillingUpdateAttachDiscount$outboundSchema = z29.pipe(
   })
 );
 var BillingUpdateCancelAction$outboundSchema = z29.enum(BillingUpdateCancelAction);
+var BillingUpdateRefundLastPayment$outboundSchema = z29.enum(BillingUpdateRefundLastPayment);
 var BillingUpdateRecalculateBalances$outboundSchema = z29.object({
   enabled: z29.boolean()
 });
@@ -7120,6 +7371,9 @@ var UpdateSubscriptionParams$outboundSchema = z29.pipe(
     cancelAction: z29.optional(BillingUpdateCancelAction$outboundSchema),
     billingCycleAnchor: z29.optional(z29.literal("now")),
     noBillingChanges: z29.optional(z29.boolean()),
+    refundLastPayment: z29.optional(
+      BillingUpdateRefundLastPayment$outboundSchema
+    ),
     recalculateBalances: z29.optional(
       z29.lazy(() => BillingUpdateRecalculateBalances$outboundSchema)
     ),
@@ -7140,6 +7394,7 @@ var UpdateSubscriptionParams$outboundSchema = z29.pipe(
       cancelAction: "cancel_action",
       billingCycleAnchor: "billing_cycle_anchor",
       noBillingChanges: "no_billing_changes",
+      refundLastPayment: "refund_last_payment",
       recalculateBalances: "recalculate_balances",
       carryOverUsages: "carry_over_usages"
     });
@@ -7659,23 +7914,29 @@ var CheckSpendLimit2$inboundSchema = z30.pipe(
     feature_id: optional3(string4()),
     enabled: z30._default(boolean2(), false),
     limit_type: optional3(CheckLimitType2$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z30.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var CheckUsageLimitInterval2$inboundSchema = inboundSchema(CheckUsageLimitInterval2);
+var CheckFilter2$inboundSchema = z30.object({
+  properties: z30.record(z30.string(), z30.any())
+});
 var CheckUsageLimit2$inboundSchema = z30.pipe(
   z30.object({
     feature_id: string4(),
     enabled: z30._default(boolean2(), true),
     limit: number2(),
-    interval: CheckUsageLimitInterval2$inboundSchema
+    interval: CheckUsageLimitInterval2$inboundSchema,
+    filter: optional3(z30.lazy(() => CheckFilter2$inboundSchema))
   }),
   z30.transform((v) => {
     return remap(v, {
@@ -7739,7 +8000,7 @@ var CheckBillingControls2$inboundSchema = z30.pipe(
   })
 );
 var ProductScenario2$inboundSchema = inboundSchema(ProductScenario2);
-var Properties2$inboundSchema = z30.pipe(
+var CheckProperties2$inboundSchema = z30.pipe(
   z30.object({
     is_free: boolean2(),
     is_one_off: boolean2(),
@@ -7774,7 +8035,7 @@ var CheckProduct2$inboundSchema = z30.pipe(
       z30.lazy(() => CheckBillingControls2$inboundSchema)
     ),
     scenario: optional3(ProductScenario2$inboundSchema),
-    properties: optional3(z30.lazy(() => Properties2$inboundSchema))
+    properties: optional3(z30.lazy(() => CheckProperties2$inboundSchema))
   }),
   z30.transform((v) => {
     return remap(v, {
@@ -8055,23 +8316,29 @@ var CheckSpendLimit1$inboundSchema = z30.pipe(
     feature_id: optional3(string4()),
     enabled: z30._default(boolean2(), false),
     limit_type: optional3(CheckLimitType1$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z30.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var CheckUsageLimitInterval1$inboundSchema = inboundSchema(CheckUsageLimitInterval1);
+var CheckFilter1$inboundSchema = z30.object({
+  properties: z30.record(z30.string(), z30.any())
+});
 var CheckUsageLimit1$inboundSchema = z30.pipe(
   z30.object({
     feature_id: string4(),
     enabled: z30._default(boolean2(), true),
     limit: number2(),
-    interval: CheckUsageLimitInterval1$inboundSchema
+    interval: CheckUsageLimitInterval1$inboundSchema,
+    filter: optional3(z30.lazy(() => CheckFilter1$inboundSchema))
   }),
   z30.transform((v) => {
     return remap(v, {
@@ -8135,7 +8402,7 @@ var CheckBillingControls1$inboundSchema = z30.pipe(
   })
 );
 var ProductScenario1$inboundSchema = inboundSchema(ProductScenario1);
-var Properties1$inboundSchema = z30.pipe(
+var CheckProperties1$inboundSchema = z30.pipe(
   z30.object({
     is_free: boolean2(),
     is_one_off: boolean2(),
@@ -8170,7 +8437,7 @@ var CheckProduct1$inboundSchema = z30.pipe(
       z30.lazy(() => CheckBillingControls1$inboundSchema)
     ),
     scenario: optional3(ProductScenario1$inboundSchema),
-    properties: optional3(z30.lazy(() => Properties1$inboundSchema))
+    properties: optional3(z30.lazy(() => CheckProperties1$inboundSchema))
   }),
   z30.transform((v) => {
     return remap(v, {
@@ -8362,23 +8629,33 @@ var CustomerDataSpendLimit$outboundSchema = z32.pipe(
     featureId: z32.optional(z32.string()),
     enabled: z32._default(z32.boolean(), false),
     limitType: z32.optional(CustomerDataLimitType$outboundSchema),
-    overageLimit: z32.optional(z32.number())
+    overageLimit: z32.optional(z32.number()),
+    skipOverageBilling: z32.optional(z32.boolean())
   }),
   z32.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
       limitType: "limit_type",
-      overageLimit: "overage_limit"
+      overageLimit: "overage_limit",
+      skipOverageBilling: "skip_overage_billing"
     });
   })
 );
 var CustomerDataUsageLimitInterval$outboundSchema = z32.enum(CustomerDataUsageLimitInterval);
+var Properties$outboundSchema = smartUnion([z32.string(), z32.number(), z32.boolean()]);
+var CustomerDataFilter$outboundSchema = z32.object({
+  properties: z32.record(
+    z32.string(),
+    smartUnion([z32.string(), z32.number(), z32.boolean()])
+  )
+});
 var CustomerDataUsageLimit$outboundSchema = z32.pipe(
   z32.object({
     featureId: z32.string(),
     enabled: z32._default(z32.boolean(), true),
     limit: z32.number(),
-    interval: CustomerDataUsageLimitInterval$outboundSchema
+    interval: CustomerDataUsageLimitInterval$outboundSchema,
+    filter: z32.optional(z32.lazy(() => CustomerDataFilter$outboundSchema))
   }),
   z32.transform((v) => {
     return remap(v, {
@@ -9053,23 +9330,31 @@ var PlanVariantDetailsSpendLimit$inboundSchema = z33.pipe(
     feature_id: optional3(string4()),
     enabled: z33._default(boolean2(), false),
     limit_type: optional3(PlanVariantDetailsLimitType$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z33.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var PlanVariantDetailsUsageLimitInterval$inboundSchema = inboundSchema(PlanVariantDetailsUsageLimitInterval);
+var PlanVariantDetailsFilter$inboundSchema = z33.object({
+  properties: z33.record(z33.string(), z33.any())
+});
 var PlanVariantDetailsUsageLimit$inboundSchema = z33.pipe(
   z33.object({
     feature_id: string4(),
     enabled: z33._default(boolean2(), true),
     limit: number2(),
-    interval: PlanVariantDetailsUsageLimitInterval$inboundSchema
+    interval: PlanVariantDetailsUsageLimitInterval$inboundSchema,
+    filter: optional3(
+      z33.lazy(() => PlanVariantDetailsFilter$inboundSchema)
+    )
   }),
   z33.transform((v) => {
     return remap(v, {
@@ -9214,23 +9499,29 @@ var PlanSpendLimit$inboundSchema = z33.pipe(
     feature_id: optional3(string4()),
     enabled: z33._default(boolean2(), false),
     limit_type: optional3(PlanLimitType$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z33.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var PlanUsageLimitInterval$inboundSchema = inboundSchema(PlanUsageLimitInterval);
+var PlanFilter$inboundSchema = z33.object({
+  properties: z33.record(z33.string(), z33.any())
+});
 var PlanUsageLimit$inboundSchema = z33.pipe(
   z33.object({
     feature_id: string4(),
     enabled: z33._default(boolean2(), true),
     limit: number2(),
-    interval: PlanUsageLimitInterval$inboundSchema
+    interval: PlanUsageLimitInterval$inboundSchema,
+    filter: optional3(z33.lazy(() => PlanFilter$inboundSchema))
   }),
   z33.transform((v) => {
     return remap(v, {
@@ -9415,23 +9706,33 @@ var CreateEntitySpendLimitRequest$outboundSchema = z34.pipe(
     featureId: z34.optional(z34.string()),
     enabled: z34._default(z34.boolean(), false),
     limitType: z34.optional(CreateEntityLimitTypeRequestBody$outboundSchema),
-    overageLimit: z34.optional(z34.number())
+    overageLimit: z34.optional(z34.number()),
+    skipOverageBilling: z34.optional(z34.boolean())
   }),
   z34.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
       limitType: "limit_type",
-      overageLimit: "overage_limit"
+      overageLimit: "overage_limit",
+      skipOverageBilling: "skip_overage_billing"
     });
   })
 );
 var CreateEntityIntervalRequestBody$outboundSchema = z34.enum(CreateEntityIntervalRequestBody);
+var CreateEntityProperties$outboundSchema = smartUnion([z34.string(), z34.number(), z34.boolean()]);
+var CreateEntityFilterRequest$outboundSchema = z34.object({
+  properties: z34.record(
+    z34.string(),
+    smartUnion([z34.string(), z34.number(), z34.boolean()])
+  )
+});
 var CreateEntityUsageLimitRequest$outboundSchema = z34.pipe(
   z34.object({
     featureId: z34.string(),
     enabled: z34._default(z34.boolean(), true),
     limit: z34.number(),
-    interval: CreateEntityIntervalRequestBody$outboundSchema
+    interval: CreateEntityIntervalRequestBody$outboundSchema,
+    filter: z34.optional(z34.lazy(() => CreateEntityFilterRequest$outboundSchema))
   }),
   z34.transform((v) => {
     return remap(v, {
@@ -9654,23 +9955,31 @@ var CreateEntitySpendLimitResponse$inboundSchema = z34.pipe(
     feature_id: optional3(string4()),
     enabled: z34._default(boolean2(), false),
     limit_type: optional3(CreateEntityLimitTypeResponse$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z34.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var CreateEntityIntervalResponse$inboundSchema = inboundSchema(CreateEntityIntervalResponse);
+var CreateEntityFilterResponse$inboundSchema = z34.object({
+  properties: z34.record(z34.string(), z34.any())
+});
 var CreateEntityUsageLimitResponse$inboundSchema = z34.pipe(
   z34.object({
     feature_id: string4(),
     enabled: z34._default(boolean2(), true),
     limit: number2(),
     interval: CreateEntityIntervalResponse$inboundSchema,
+    filter: optional3(
+      z34.lazy(() => CreateEntityFilterResponse$inboundSchema)
+    ),
     usage: optional3(number2())
   }),
   z34.transform((v) => {
@@ -10414,25 +10723,35 @@ var CreatePlanSpendLimitRequest$outboundSchema = z36.pipe(
     featureId: z36.optional(z36.string()),
     enabled: z36._default(z36.boolean(), false),
     limitType: z36.optional(CreatePlanLimitTypeRequestBody$outboundSchema),
-    overageLimit: z36.optional(z36.number())
+    overageLimit: z36.optional(z36.number()),
+    skipOverageBilling: z36.optional(z36.boolean())
   }),
   z36.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
       limitType: "limit_type",
-      overageLimit: "overage_limit"
+      overageLimit: "overage_limit",
+      skipOverageBilling: "skip_overage_billing"
     });
   })
 );
 var CreatePlanUsageLimitIntervalRequestBody$outboundSchema = z36.enum(
   CreatePlanUsageLimitIntervalRequestBody
 );
+var CreatePlanProperties$outboundSchema = smartUnion([z36.string(), z36.number(), z36.boolean()]);
+var CreatePlanFilterRequest$outboundSchema = z36.object({
+  properties: z36.record(
+    z36.string(),
+    smartUnion([z36.string(), z36.number(), z36.boolean()])
+  )
+});
 var CreatePlanUsageLimitRequest$outboundSchema = z36.pipe(
   z36.object({
     featureId: z36.string(),
     enabled: z36._default(z36.boolean(), true),
     limit: z36.number(),
-    interval: CreatePlanUsageLimitIntervalRequestBody$outboundSchema
+    interval: CreatePlanUsageLimitIntervalRequestBody$outboundSchema,
+    filter: z36.optional(z36.lazy(() => CreatePlanFilterRequest$outboundSchema))
   }),
   z36.transform((v) => {
     return remap(v, {
@@ -10919,23 +11238,31 @@ var CreatePlanVariantDetailsSpendLimit$inboundSchema = z36.pipe(
     feature_id: optional3(string4()),
     enabled: z36._default(boolean2(), false),
     limit_type: optional3(CreatePlanVariantDetailsLimitType$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z36.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var CreatePlanVariantDetailsUsageLimitInterval$inboundSchema = inboundSchema(CreatePlanVariantDetailsUsageLimitInterval);
+var CreatePlanVariantDetailsFilter$inboundSchema = z36.object({
+  properties: z36.record(z36.string(), z36.any())
+});
 var CreatePlanVariantDetailsUsageLimit$inboundSchema = z36.pipe(
   z36.object({
     feature_id: string4(),
     enabled: z36._default(boolean2(), true),
     limit: number2(),
-    interval: CreatePlanVariantDetailsUsageLimitInterval$inboundSchema
+    interval: CreatePlanVariantDetailsUsageLimitInterval$inboundSchema,
+    filter: optional3(
+      z36.lazy(() => CreatePlanVariantDetailsFilter$inboundSchema)
+    )
   }),
   z36.transform((v) => {
     return remap(v, {
@@ -11084,23 +11411,31 @@ var CreatePlanSpendLimitResponse$inboundSchema = z36.pipe(
     feature_id: optional3(string4()),
     enabled: z36._default(boolean2(), false),
     limit_type: optional3(CreatePlanLimitTypeResponse$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z36.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var CreatePlanUsageLimitIntervalResponse$inboundSchema = inboundSchema(CreatePlanUsageLimitIntervalResponse);
+var CreatePlanFilterResponse$inboundSchema = z36.object({
+  properties: z36.record(z36.string(), z36.any())
+});
 var CreatePlanUsageLimitResponse$inboundSchema = z36.pipe(
   z36.object({
     feature_id: string4(),
     enabled: z36._default(boolean2(), true),
     limit: number2(),
-    interval: CreatePlanUsageLimitIntervalResponse$inboundSchema
+    interval: CreatePlanUsageLimitIntervalResponse$inboundSchema,
+    filter: optional3(
+      z36.lazy(() => CreatePlanFilterResponse$inboundSchema)
+    )
   }),
   z36.transform((v) => {
     return remap(v, {
@@ -11418,7 +11753,8 @@ var CreateScheduleStatus = {
 var CreateScheduleCode = {
   ThreedsRequired: "3ds_required",
   PaymentMethodRequired: "payment_method_required",
-  PaymentFailed: "payment_failed"
+  PaymentFailed: "payment_failed",
+  PaymentProcessing: "payment_processing"
 };
 var CreateScheduleInvoiceMode$outboundSchema = z38.pipe(
   z38.object({
@@ -11766,23 +12102,29 @@ var CreateScheduleSpendLimit2$outboundSchema = z38.pipe(
     featureId: z38.optional(z38.string()),
     enabled: z38._default(z38.boolean(), false),
     limitType: z38.optional(CreateScheduleLimitType2$outboundSchema),
-    overageLimit: z38.optional(z38.number())
+    overageLimit: z38.optional(z38.number()),
+    skipOverageBilling: z38.optional(z38.boolean())
   }),
   z38.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
       limitType: "limit_type",
-      overageLimit: "overage_limit"
+      overageLimit: "overage_limit",
+      skipOverageBilling: "skip_overage_billing"
     });
   })
 );
 var CreateScheduleUsageLimitInterval2$outboundSchema = z38.enum(CreateScheduleUsageLimitInterval2);
+var CreateScheduleFilter2$outboundSchema = z38.object({
+  properties: z38.record(z38.string(), z38.any())
+});
 var CreateScheduleUsageLimit2$outboundSchema = z38.pipe(
   z38.object({
     featureId: z38.string(),
     enabled: z38._default(z38.boolean(), true),
     limit: z38.number(),
-    interval: CreateScheduleUsageLimitInterval2$outboundSchema
+    interval: CreateScheduleUsageLimitInterval2$outboundSchema,
+    filter: z38.optional(z38.lazy(() => CreateScheduleFilter2$outboundSchema))
   }),
   z38.transform((v) => {
     return remap(v, {
@@ -12151,23 +12493,29 @@ var CustomerSpendLimit$inboundSchema = z40.pipe(
     feature_id: optional3(string4()),
     enabled: z40._default(boolean2(), false),
     limit_type: optional3(CustomerLimitType$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z40.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var CustomerUsageLimitInterval$inboundSchema = inboundSchema(CustomerUsageLimitInterval);
+var CustomerFilter$inboundSchema = z40.object({
+  properties: z40.record(z40.string(), z40.any())
+});
 var CustomerUsageLimit$inboundSchema = z40.pipe(
   z40.object({
     feature_id: string4(),
     enabled: z40._default(boolean2(), true),
     limit: number2(),
     interval: CustomerUsageLimitInterval$inboundSchema,
+    filter: optional3(z40.lazy(() => CustomerFilter$inboundSchema)),
     usage: optional3(number2())
   }),
   z40.transform((v) => {
@@ -12825,23 +13173,29 @@ var GetCustomerSpendLimit$inboundSchema = z47.pipe(
     feature_id: optional3(string4()),
     enabled: z47._default(boolean2(), false),
     limit_type: optional3(GetCustomerLimitType$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z47.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var GetCustomerUsageLimitInterval$inboundSchema = inboundSchema(GetCustomerUsageLimitInterval);
+var GetCustomerFilter$inboundSchema = z47.object({
+  properties: z47.record(z47.string(), z47.any())
+});
 var GetCustomerUsageLimit$inboundSchema = z47.pipe(
   z47.object({
     feature_id: string4(),
     enabled: z47._default(boolean2(), true),
     limit: number2(),
     interval: GetCustomerUsageLimitInterval$inboundSchema,
+    filter: optional3(z47.lazy(() => GetCustomerFilter$inboundSchema)),
     usage: optional3(number2())
   }),
   z47.transform((v) => {
@@ -13429,23 +13783,29 @@ var GetEntitySpendLimit$inboundSchema = z48.pipe(
     feature_id: optional3(string4()),
     enabled: z48._default(boolean2(), false),
     limit_type: optional3(GetEntityLimitType$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z48.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var GetEntityInterval$inboundSchema = inboundSchema(GetEntityInterval);
+var GetEntityFilter$inboundSchema = z48.object({
+  properties: z48.record(z48.string(), z48.any())
+});
 var GetEntityUsageLimit$inboundSchema = z48.pipe(
   z48.object({
     feature_id: string4(),
     enabled: z48._default(boolean2(), true),
     limit: number2(),
     interval: GetEntityInterval$inboundSchema,
+    filter: optional3(z48.lazy(() => GetEntityFilter$inboundSchema)),
     usage: optional3(number2())
   }),
   z48.transform((v) => {
@@ -13706,25 +14066,35 @@ var GetOrCreateCustomerSpendLimit$outboundSchema = z50.pipe(
     featureId: z50.optional(z50.string()),
     enabled: z50._default(z50.boolean(), false),
     limitType: z50.optional(GetOrCreateCustomerLimitType$outboundSchema),
-    overageLimit: z50.optional(z50.number())
+    overageLimit: z50.optional(z50.number()),
+    skipOverageBilling: z50.optional(z50.boolean())
   }),
   z50.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
       limitType: "limit_type",
-      overageLimit: "overage_limit"
+      overageLimit: "overage_limit",
+      skipOverageBilling: "skip_overage_billing"
     });
   })
 );
 var GetOrCreateCustomerUsageLimitInterval$outboundSchema = z50.enum(
   GetOrCreateCustomerUsageLimitInterval
 );
+var GetOrCreateCustomerProperties$outboundSchema = smartUnion([z50.string(), z50.number(), z50.boolean()]);
+var GetOrCreateCustomerFilter$outboundSchema = z50.object({
+  properties: z50.record(
+    z50.string(),
+    smartUnion([z50.string(), z50.number(), z50.boolean()])
+  )
+});
 var GetOrCreateCustomerUsageLimit$outboundSchema = z50.pipe(
   z50.object({
     featureId: z50.string(),
     enabled: z50._default(z50.boolean(), true),
     limit: z50.number(),
-    interval: GetOrCreateCustomerUsageLimitInterval$outboundSchema
+    interval: GetOrCreateCustomerUsageLimitInterval$outboundSchema,
+    filter: z50.optional(z50.lazy(() => GetOrCreateCustomerFilter$outboundSchema))
   }),
   z50.transform((v) => {
     return remap(v, {
@@ -14421,23 +14791,31 @@ var GetPlanVariantDetailsSpendLimit$inboundSchema = z51.pipe(
     feature_id: optional3(string4()),
     enabled: z51._default(boolean2(), false),
     limit_type: optional3(GetPlanVariantDetailsLimitType$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z51.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var GetPlanVariantDetailsUsageLimitInterval$inboundSchema = inboundSchema(GetPlanVariantDetailsUsageLimitInterval);
+var GetPlanVariantDetailsFilter$inboundSchema = z51.object({
+  properties: z51.record(z51.string(), z51.any())
+});
 var GetPlanVariantDetailsUsageLimit$inboundSchema = z51.pipe(
   z51.object({
     feature_id: string4(),
     enabled: z51._default(boolean2(), true),
     limit: number2(),
-    interval: GetPlanVariantDetailsUsageLimitInterval$inboundSchema
+    interval: GetPlanVariantDetailsUsageLimitInterval$inboundSchema,
+    filter: optional3(
+      z51.lazy(() => GetPlanVariantDetailsFilter$inboundSchema)
+    )
   }),
   z51.transform((v) => {
     return remap(v, {
@@ -14584,23 +14962,29 @@ var GetPlanSpendLimit$inboundSchema = z51.pipe(
     feature_id: optional3(string4()),
     enabled: z51._default(boolean2(), false),
     limit_type: optional3(GetPlanLimitType$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z51.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var GetPlanUsageLimitInterval$inboundSchema = inboundSchema(GetPlanUsageLimitInterval);
+var GetPlanFilter$inboundSchema = z51.object({
+  properties: z51.record(z51.string(), z51.any())
+});
 var GetPlanUsageLimit$inboundSchema = z51.pipe(
   z51.object({
     feature_id: string4(),
     enabled: z51._default(boolean2(), true),
     limit: number2(),
-    interval: GetPlanUsageLimitInterval$inboundSchema
+    interval: GetPlanUsageLimitInterval$inboundSchema,
+    filter: optional3(z51.lazy(() => GetPlanFilter$inboundSchema))
   }),
   z51.transform((v) => {
     return remap(v, {
@@ -14836,15 +15220,20 @@ var ImportStatus = {
   Expired: "expired"
 };
 var ImportInterval = {
+  Lifetime: "lifetime",
+  Minute: "minute",
   Hour: "hour",
   Day: "day",
   Week: "week",
   Month: "month",
+  Quarter: "quarter",
+  SemiAnnual: "semi_annual",
   Year: "year"
 };
 var ImportBillingBehavior = {
   Included: "included",
-  Prepaid: "prepaid"
+  Prepaid: "prepaid",
+  UsageBased: "usage_based"
 };
 var ImportCustomerData$outboundSchema = z53.object({
   name: z53.optional(z53.string()),
@@ -14883,7 +15272,7 @@ var ImportFeatureQuantity$outboundSchema = z53.pipe(
 );
 var ImportInterval$outboundSchema = z53.enum(ImportInterval);
 var ImportBillingBehavior$outboundSchema = z53.enum(ImportBillingBehavior);
-var Filter$outboundSchema = z53.pipe(
+var ImportFilter$outboundSchema = z53.pipe(
   z53.object({
     interval: z53.optional(z53.nullable(ImportInterval$outboundSchema)),
     billingBehavior: z53.optional(ImportBillingBehavior$outboundSchema)
@@ -14897,7 +15286,7 @@ var Filter$outboundSchema = z53.pipe(
 var ImportBalance$outboundSchema = z53.pipe(
   z53.object({
     featureId: z53.string(),
-    filter: z53.optional(z53.lazy(() => Filter$outboundSchema)),
+    filter: z53.optional(z53.lazy(() => ImportFilter$outboundSchema)),
     usage: z53.optional(z53.number()),
     balance: z53.optional(z53.number()),
     nextResetAt: z53.optional(z53.number())
@@ -15169,23 +15558,29 @@ var ListCustomersSpendLimit$inboundSchema = z55.pipe(
     feature_id: optional3(string4()),
     enabled: z55._default(boolean2(), false),
     limit_type: optional3(ListCustomersLimitType$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z55.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var ListCustomersUsageLimitInterval$inboundSchema = inboundSchema(ListCustomersUsageLimitInterval);
+var ListCustomersFilter$inboundSchema = z55.object({
+  properties: z55.record(z55.string(), z55.any())
+});
 var ListCustomersUsageLimit$inboundSchema = z55.pipe(
   z55.object({
     feature_id: string4(),
     enabled: z55._default(boolean2(), true),
     limit: number2(),
     interval: ListCustomersUsageLimitInterval$inboundSchema,
+    filter: optional3(z55.lazy(() => ListCustomersFilter$inboundSchema)),
     usage: optional3(number2())
   }),
   z55.transform((v) => {
@@ -15688,23 +16083,29 @@ var ListEntitiesSpendLimit$inboundSchema = z56.pipe(
     feature_id: optional3(string4()),
     enabled: z56._default(boolean2(), false),
     limit_type: optional3(ListEntitiesLimitType$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z56.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var ListEntitiesInterval$inboundSchema = inboundSchema(ListEntitiesInterval);
+var ListEntitiesFilter$inboundSchema = z56.object({
+  properties: z56.record(z56.string(), z56.any())
+});
 var ListEntitiesUsageLimit$inboundSchema = z56.pipe(
   z56.object({
     feature_id: string4(),
     enabled: z56._default(boolean2(), true),
     limit: number2(),
     interval: ListEntitiesInterval$inboundSchema,
+    filter: optional3(z56.lazy(() => ListEntitiesFilter$inboundSchema)),
     usage: optional3(number2())
   }),
   z56.transform((v) => {
@@ -16610,23 +17011,31 @@ var ListPlansVariantDetailsSpendLimit$inboundSchema = z59.pipe(
     feature_id: optional3(string4()),
     enabled: z59._default(boolean2(), false),
     limit_type: optional3(ListPlansVariantDetailsLimitType$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z59.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var ListPlansVariantDetailsUsageLimitInterval$inboundSchema = inboundSchema(ListPlansVariantDetailsUsageLimitInterval);
+var ListPlansVariantDetailsFilter$inboundSchema = z59.object({
+  properties: z59.record(z59.string(), z59.any())
+});
 var ListPlansVariantDetailsUsageLimit$inboundSchema = z59.pipe(
   z59.object({
     feature_id: string4(),
     enabled: z59._default(boolean2(), true),
     limit: number2(),
-    interval: ListPlansVariantDetailsUsageLimitInterval$inboundSchema
+    interval: ListPlansVariantDetailsUsageLimitInterval$inboundSchema,
+    filter: optional3(
+      z59.lazy(() => ListPlansVariantDetailsFilter$inboundSchema)
+    )
   }),
   z59.transform((v) => {
     return remap(v, {
@@ -16775,23 +17184,29 @@ var ListPlansSpendLimit$inboundSchema = z59.pipe(
     feature_id: optional3(string4()),
     enabled: z59._default(boolean2(), false),
     limit_type: optional3(ListPlansLimitType$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z59.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var ListPlansUsageLimitInterval$inboundSchema = inboundSchema(ListPlansUsageLimitInterval);
+var ListPlansFilter$inboundSchema = z59.object({
+  properties: z59.record(z59.string(), z59.any())
+});
 var ListPlansUsageLimit$inboundSchema = z59.pipe(
   z59.object({
     feature_id: string4(),
     enabled: z59._default(boolean2(), true),
     limit: number2(),
-    interval: ListPlansUsageLimitInterval$inboundSchema
+    interval: ListPlansUsageLimitInterval$inboundSchema,
+    filter: optional3(z59.lazy(() => ListPlansFilter$inboundSchema))
   }),
   z59.transform((v) => {
     return remap(v, {
@@ -17145,7 +17560,8 @@ var MultiAttachThresholdType = {
 var MultiAttachCode = {
   ThreedsRequired: "3ds_required",
   PaymentMethodRequired: "payment_method_required",
-  PaymentFailed: "payment_failed"
+  PaymentFailed: "payment_failed",
+  PaymentProcessing: "payment_processing"
 };
 var MultiAttachPriceInterval$outboundSchema = z62.enum(MultiAttachPriceInterval);
 var MultiAttachBasePrice$outboundSchema = z62.pipe(
@@ -17344,23 +17760,33 @@ var MultiAttachSpendLimit$outboundSchema = z62.pipe(
     featureId: z62.optional(z62.string()),
     enabled: z62._default(z62.boolean(), false),
     limitType: z62.optional(MultiAttachLimitType$outboundSchema),
-    overageLimit: z62.optional(z62.number())
+    overageLimit: z62.optional(z62.number()),
+    skipOverageBilling: z62.optional(z62.boolean())
   }),
   z62.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
       limitType: "limit_type",
-      overageLimit: "overage_limit"
+      overageLimit: "overage_limit",
+      skipOverageBilling: "skip_overage_billing"
     });
   })
 );
 var MultiAttachEntityDataInterval$outboundSchema = z62.enum(MultiAttachEntityDataInterval);
+var MultiAttachProperties$outboundSchema = smartUnion([z62.string(), z62.number(), z62.boolean()]);
+var MultiAttachFilter$outboundSchema = z62.object({
+  properties: z62.record(
+    z62.string(),
+    smartUnion([z62.string(), z62.number(), z62.boolean()])
+  )
+});
 var MultiAttachUsageLimit$outboundSchema = z62.pipe(
   z62.object({
     featureId: z62.string(),
     enabled: z62._default(z62.boolean(), true),
     limit: z62.number(),
-    interval: MultiAttachEntityDataInterval$outboundSchema
+    interval: MultiAttachEntityDataInterval$outboundSchema,
+    filter: z62.optional(z62.lazy(() => MultiAttachFilter$outboundSchema))
   }),
   z62.transform((v) => {
     return remap(v, {
@@ -18030,23 +18456,33 @@ var PreviewAttachSpendLimit$outboundSchema = z64.pipe(
     featureId: z64.optional(z64.string()),
     enabled: z64._default(z64.boolean(), false),
     limitType: z64.optional(PreviewAttachLimitType$outboundSchema),
-    overageLimit: z64.optional(z64.number())
+    overageLimit: z64.optional(z64.number()),
+    skipOverageBilling: z64.optional(z64.boolean())
   }),
   z64.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
       limitType: "limit_type",
-      overageLimit: "overage_limit"
+      overageLimit: "overage_limit",
+      skipOverageBilling: "skip_overage_billing"
     });
   })
 );
 var PreviewAttachUsageLimitInterval$outboundSchema = z64.enum(PreviewAttachUsageLimitInterval);
+var PreviewAttachProperties$outboundSchema = smartUnion([z64.string(), z64.number(), z64.boolean()]);
+var PreviewAttachFilter$outboundSchema = z64.object({
+  properties: z64.record(
+    z64.string(),
+    smartUnion([z64.string(), z64.number(), z64.boolean()])
+  )
+});
 var PreviewAttachUsageLimit$outboundSchema = z64.pipe(
   z64.object({
     featureId: z64.string(),
     enabled: z64._default(z64.boolean(), true),
     limit: z64.number(),
-    interval: PreviewAttachUsageLimitInterval$outboundSchema
+    interval: PreviewAttachUsageLimitInterval$outboundSchema,
+    filter: z64.optional(z64.lazy(() => PreviewAttachFilter$outboundSchema))
   }),
   z64.transform((v) => {
     return remap(v, {
@@ -18821,23 +19257,33 @@ var PreviewMultiAttachSpendLimit$outboundSchema = z65.pipe(
     featureId: z65.optional(z65.string()),
     enabled: z65._default(z65.boolean(), false),
     limitType: z65.optional(PreviewMultiAttachLimitType$outboundSchema),
-    overageLimit: z65.optional(z65.number())
+    overageLimit: z65.optional(z65.number()),
+    skipOverageBilling: z65.optional(z65.boolean())
   }),
   z65.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
       limitType: "limit_type",
-      overageLimit: "overage_limit"
+      overageLimit: "overage_limit",
+      skipOverageBilling: "skip_overage_billing"
     });
   })
 );
 var PreviewMultiAttachEntityDataInterval$outboundSchema = z65.enum(PreviewMultiAttachEntityDataInterval);
+var PreviewMultiAttachProperties$outboundSchema = smartUnion([z65.string(), z65.number(), z65.boolean()]);
+var PreviewMultiAttachFilter$outboundSchema = z65.object({
+  properties: z65.record(
+    z65.string(),
+    smartUnion([z65.string(), z65.number(), z65.boolean()])
+  )
+});
 var PreviewMultiAttachUsageLimit$outboundSchema = z65.pipe(
   z65.object({
     featureId: z65.string(),
     enabled: z65._default(z65.boolean(), true),
     limit: z65.number(),
-    interval: PreviewMultiAttachEntityDataInterval$outboundSchema
+    interval: PreviewMultiAttachEntityDataInterval$outboundSchema,
+    filter: z65.optional(z65.lazy(() => PreviewMultiAttachFilter$outboundSchema))
   }),
   z65.transform((v) => {
     return remap(v, {
@@ -19368,6 +19814,10 @@ var PreviewUpdateCancelAction = {
   CancelEndOfCycle: "cancel_end_of_cycle",
   Uncancel: "uncancel"
 };
+var PreviewUpdateRefundLastPayment = {
+  Prorated: "prorated",
+  Full: "full"
+};
 var Intent = {
   UpdatePlan: "update_plan",
   UpdateQuantity: "update_quantity",
@@ -19694,23 +20144,33 @@ var PreviewUpdateSpendLimit$outboundSchema = z66.pipe(
     featureId: z66.optional(z66.string()),
     enabled: z66._default(z66.boolean(), false),
     limitType: z66.optional(PreviewUpdateLimitType$outboundSchema),
-    overageLimit: z66.optional(z66.number())
+    overageLimit: z66.optional(z66.number()),
+    skipOverageBilling: z66.optional(z66.boolean())
   }),
   z66.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
       limitType: "limit_type",
-      overageLimit: "overage_limit"
+      overageLimit: "overage_limit",
+      skipOverageBilling: "skip_overage_billing"
     });
   })
 );
 var PreviewUpdateUsageLimitInterval$outboundSchema = z66.enum(PreviewUpdateUsageLimitInterval);
+var PreviewUpdateProperties$outboundSchema = smartUnion([z66.string(), z66.number(), z66.boolean()]);
+var PreviewUpdateFilter$outboundSchema = z66.object({
+  properties: z66.record(
+    z66.string(),
+    smartUnion([z66.string(), z66.number(), z66.boolean()])
+  )
+});
 var PreviewUpdateUsageLimit$outboundSchema = z66.pipe(
   z66.object({
     featureId: z66.string(),
     enabled: z66._default(z66.boolean(), true),
     limit: z66.number(),
-    interval: PreviewUpdateUsageLimitInterval$outboundSchema
+    interval: PreviewUpdateUsageLimitInterval$outboundSchema,
+    filter: z66.optional(z66.lazy(() => PreviewUpdateFilter$outboundSchema))
   }),
   z66.transform((v) => {
     return remap(v, {
@@ -19834,6 +20294,7 @@ var PreviewUpdateAttachDiscount$outboundSchema = z66.pipe(
   })
 );
 var PreviewUpdateCancelAction$outboundSchema = z66.enum(PreviewUpdateCancelAction);
+var PreviewUpdateRefundLastPayment$outboundSchema = z66.enum(PreviewUpdateRefundLastPayment);
 var PreviewUpdateRecalculateBalances$outboundSchema = z66.object({
   enabled: z66.boolean()
 });
@@ -19875,6 +20336,9 @@ var PreviewUpdateParams$outboundSchema = z66.pipe(
     cancelAction: z66.optional(PreviewUpdateCancelAction$outboundSchema),
     billingCycleAnchor: z66.optional(z66.literal("now")),
     noBillingChanges: z66.optional(z66.boolean()),
+    refundLastPayment: z66.optional(
+      PreviewUpdateRefundLastPayment$outboundSchema
+    ),
     recalculateBalances: z66.optional(
       z66.lazy(() => PreviewUpdateRecalculateBalances$outboundSchema)
     ),
@@ -19895,6 +20359,7 @@ var PreviewUpdateParams$outboundSchema = z66.pipe(
       cancelAction: "cancel_action",
       billingCycleAnchor: "billing_cycle_anchor",
       noBillingChanges: "no_billing_changes",
+      refundLastPayment: "refund_last_payment",
       recalculateBalances: "recalculate_balances",
       carryOverUsages: "carry_over_usages"
     });
@@ -20713,23 +21178,33 @@ var SetupPaymentSpendLimit$outboundSchema = z71.pipe(
     featureId: z71.optional(z71.string()),
     enabled: z71._default(z71.boolean(), false),
     limitType: z71.optional(SetupPaymentLimitType$outboundSchema),
-    overageLimit: z71.optional(z71.number())
+    overageLimit: z71.optional(z71.number()),
+    skipOverageBilling: z71.optional(z71.boolean())
   }),
   z71.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
       limitType: "limit_type",
-      overageLimit: "overage_limit"
+      overageLimit: "overage_limit",
+      skipOverageBilling: "skip_overage_billing"
     });
   })
 );
 var SetupPaymentUsageLimitInterval$outboundSchema = z71.enum(SetupPaymentUsageLimitInterval);
+var SetupPaymentProperties$outboundSchema = smartUnion([z71.string(), z71.number(), z71.boolean()]);
+var SetupPaymentFilter$outboundSchema = z71.object({
+  properties: z71.record(
+    z71.string(),
+    smartUnion([z71.string(), z71.number(), z71.boolean()])
+  )
+});
 var SetupPaymentUsageLimit$outboundSchema = z71.pipe(
   z71.object({
     featureId: z71.string(),
     enabled: z71._default(z71.boolean(), true),
     limit: z71.number(),
-    interval: SetupPaymentUsageLimitInterval$outboundSchema
+    interval: SetupPaymentUsageLimitInterval$outboundSchema,
+    filter: z71.optional(z71.lazy(() => SetupPaymentFilter$outboundSchema))
   }),
   z71.transform((v) => {
     return remap(v, {
@@ -21516,25 +21991,37 @@ var UpdateCustomerSpendLimitRequest$outboundSchema = z76.pipe(
     featureId: z76.optional(z76.string()),
     enabled: z76._default(z76.boolean(), false),
     limitType: z76.optional(UpdateCustomerLimitTypeRequestBody$outboundSchema),
-    overageLimit: z76.optional(z76.number())
+    overageLimit: z76.optional(z76.number()),
+    skipOverageBilling: z76.optional(z76.boolean())
   }),
   z76.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
       limitType: "limit_type",
-      overageLimit: "overage_limit"
+      overageLimit: "overage_limit",
+      skipOverageBilling: "skip_overage_billing"
     });
   })
 );
 var UpdateCustomerUsageLimitIntervalRequestBody$outboundSchema = z76.enum(
   UpdateCustomerUsageLimitIntervalRequestBody
 );
+var UpdateCustomerProperties$outboundSchema = smartUnion([z76.string(), z76.number(), z76.boolean()]);
+var UpdateCustomerFilterRequest$outboundSchema = z76.object({
+  properties: z76.record(
+    z76.string(),
+    smartUnion([z76.string(), z76.number(), z76.boolean()])
+  )
+});
 var UpdateCustomerUsageLimitRequest$outboundSchema = z76.pipe(
   z76.object({
     featureId: z76.string(),
     enabled: z76._default(z76.boolean(), true),
     limit: z76.number(),
-    interval: UpdateCustomerUsageLimitIntervalRequestBody$outboundSchema
+    interval: UpdateCustomerUsageLimitIntervalRequestBody$outboundSchema,
+    filter: z76.optional(
+      z76.lazy(() => UpdateCustomerFilterRequest$outboundSchema)
+    )
   }),
   z76.transform((v) => {
     return remap(v, {
@@ -21700,23 +22187,31 @@ var UpdateCustomerSpendLimitResponse$inboundSchema = z76.pipe(
     feature_id: optional3(string4()),
     enabled: z76._default(boolean2(), false),
     limit_type: optional3(UpdateCustomerLimitTypeResponse$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z76.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var UpdateCustomerUsageLimitIntervalResponse$inboundSchema = inboundSchema(UpdateCustomerUsageLimitIntervalResponse);
+var UpdateCustomerFilterResponse$inboundSchema = z76.object({
+  properties: z76.record(z76.string(), z76.any())
+});
 var UpdateCustomerUsageLimitResponse$inboundSchema = z76.pipe(
   z76.object({
     feature_id: string4(),
     enabled: z76._default(boolean2(), true),
     limit: number2(),
     interval: UpdateCustomerUsageLimitIntervalResponse$inboundSchema,
+    filter: optional3(
+      z76.lazy(() => UpdateCustomerFilterResponse$inboundSchema)
+    ),
     usage: optional3(number2())
   }),
   z76.transform((v) => {
@@ -22059,23 +22554,33 @@ var UpdateEntitySpendLimitRequest$outboundSchema = z77.pipe(
     featureId: z77.optional(z77.string()),
     enabled: z77._default(z77.boolean(), false),
     limitType: z77.optional(UpdateEntityLimitTypeRequestBody$outboundSchema),
-    overageLimit: z77.optional(z77.number())
+    overageLimit: z77.optional(z77.number()),
+    skipOverageBilling: z77.optional(z77.boolean())
   }),
   z77.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
       limitType: "limit_type",
-      overageLimit: "overage_limit"
+      overageLimit: "overage_limit",
+      skipOverageBilling: "skip_overage_billing"
     });
   })
 );
 var UpdateEntityIntervalRequestBody$outboundSchema = z77.enum(UpdateEntityIntervalRequestBody);
+var UpdateEntityProperties$outboundSchema = smartUnion([z77.string(), z77.number(), z77.boolean()]);
+var UpdateEntityFilterRequest$outboundSchema = z77.object({
+  properties: z77.record(
+    z77.string(),
+    smartUnion([z77.string(), z77.number(), z77.boolean()])
+  )
+});
 var UpdateEntityUsageLimitRequest$outboundSchema = z77.pipe(
   z77.object({
     featureId: z77.string(),
     enabled: z77._default(z77.boolean(), true),
     limit: z77.number(),
-    interval: UpdateEntityIntervalRequestBody$outboundSchema
+    interval: UpdateEntityIntervalRequestBody$outboundSchema,
+    filter: z77.optional(z77.lazy(() => UpdateEntityFilterRequest$outboundSchema))
   }),
   z77.transform((v) => {
     return remap(v, {
@@ -22293,23 +22798,31 @@ var UpdateEntitySpendLimitResponse$inboundSchema = z77.pipe(
     feature_id: optional3(string4()),
     enabled: z77._default(boolean2(), false),
     limit_type: optional3(UpdateEntityLimitTypeResponse$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z77.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var UpdateEntityIntervalResponse$inboundSchema = inboundSchema(UpdateEntityIntervalResponse);
+var UpdateEntityFilterResponse$inboundSchema = z77.object({
+  properties: z77.record(z77.string(), z77.any())
+});
 var UpdateEntityUsageLimitResponse$inboundSchema = z77.pipe(
   z77.object({
     feature_id: string4(),
     enabled: z77._default(boolean2(), true),
     limit: number2(),
     interval: UpdateEntityIntervalResponse$inboundSchema,
+    filter: optional3(
+      z77.lazy(() => UpdateEntityFilterResponse$inboundSchema)
+    ),
     usage: optional3(number2())
   }),
   z77.transform((v) => {
@@ -23172,25 +23685,35 @@ var UpdatePlanSpendLimitRequest$outboundSchema = z79.pipe(
     featureId: z79.optional(z79.string()),
     enabled: z79._default(z79.boolean(), false),
     limitType: z79.optional(UpdatePlanLimitTypeRequestBody$outboundSchema),
-    overageLimit: z79.optional(z79.number())
+    overageLimit: z79.optional(z79.number()),
+    skipOverageBilling: z79.optional(z79.boolean())
   }),
   z79.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
       limitType: "limit_type",
-      overageLimit: "overage_limit"
+      overageLimit: "overage_limit",
+      skipOverageBilling: "skip_overage_billing"
     });
   })
 );
 var UpdatePlanUsageLimitIntervalRequestBody$outboundSchema = z79.enum(
   UpdatePlanUsageLimitIntervalRequestBody
 );
+var UpdatePlanProperties$outboundSchema = smartUnion([z79.string(), z79.number(), z79.boolean()]);
+var UpdatePlanFilterRequest$outboundSchema = z79.object({
+  properties: z79.record(
+    z79.string(),
+    smartUnion([z79.string(), z79.number(), z79.boolean()])
+  )
+});
 var UpdatePlanUsageLimitRequest$outboundSchema = z79.pipe(
   z79.object({
     featureId: z79.string(),
     enabled: z79._default(z79.boolean(), true),
     limit: z79.number(),
-    interval: UpdatePlanUsageLimitIntervalRequestBody$outboundSchema
+    interval: UpdatePlanUsageLimitIntervalRequestBody$outboundSchema,
+    filter: z79.optional(z79.lazy(() => UpdatePlanFilterRequest$outboundSchema))
   }),
   z79.transform((v) => {
     return remap(v, {
@@ -23455,23 +23978,33 @@ var VariantSpendLimit$outboundSchema = z79.pipe(
     featureId: z79.optional(z79.string()),
     enabled: z79._default(z79.boolean(), false),
     limitType: z79.optional(VariantLimitType$outboundSchema),
-    overageLimit: z79.optional(z79.number())
+    overageLimit: z79.optional(z79.number()),
+    skipOverageBilling: z79.optional(z79.boolean())
   }),
   z79.transform((v) => {
     return remap(v, {
       featureId: "feature_id",
       limitType: "limit_type",
-      overageLimit: "overage_limit"
+      overageLimit: "overage_limit",
+      skipOverageBilling: "skip_overage_billing"
     });
   })
 );
 var VariantUsageLimitInterval$outboundSchema = z79.enum(VariantUsageLimitInterval);
+var VariantProperties$outboundSchema = smartUnion([z79.string(), z79.number(), z79.boolean()]);
+var VariantFilter$outboundSchema = z79.object({
+  properties: z79.record(
+    z79.string(),
+    smartUnion([z79.string(), z79.number(), z79.boolean()])
+  )
+});
 var VariantUsageLimit$outboundSchema = z79.pipe(
   z79.object({
     featureId: z79.string(),
     enabled: z79._default(z79.boolean(), true),
     limit: z79.number(),
-    interval: VariantUsageLimitInterval$outboundSchema
+    interval: VariantUsageLimitInterval$outboundSchema,
+    filter: z79.optional(z79.lazy(() => VariantFilter$outboundSchema))
   }),
   z79.transform((v) => {
     return remap(v, {
@@ -24033,23 +24566,31 @@ var UpdatePlanVariantDetailsSpendLimit$inboundSchema = z79.pipe(
     feature_id: optional3(string4()),
     enabled: z79._default(boolean2(), false),
     limit_type: optional3(UpdatePlanVariantDetailsLimitType$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z79.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var UpdatePlanVariantDetailsUsageLimitInterval$inboundSchema = inboundSchema(UpdatePlanVariantDetailsUsageLimitInterval);
+var UpdatePlanVariantDetailsFilter$inboundSchema = z79.object({
+  properties: z79.record(z79.string(), z79.any())
+});
 var UpdatePlanVariantDetailsUsageLimit$inboundSchema = z79.pipe(
   z79.object({
     feature_id: string4(),
     enabled: z79._default(boolean2(), true),
     limit: number2(),
-    interval: UpdatePlanVariantDetailsUsageLimitInterval$inboundSchema
+    interval: UpdatePlanVariantDetailsUsageLimitInterval$inboundSchema,
+    filter: optional3(
+      z79.lazy(() => UpdatePlanVariantDetailsFilter$inboundSchema)
+    )
   }),
   z79.transform((v) => {
     return remap(v, {
@@ -24200,23 +24741,31 @@ var UpdatePlanSpendLimitResponse$inboundSchema = z79.pipe(
     feature_id: optional3(string4()),
     enabled: z79._default(boolean2(), false),
     limit_type: optional3(UpdatePlanLimitTypeResponse$inboundSchema),
-    overage_limit: optional3(number2())
+    overage_limit: optional3(number2()),
+    skip_overage_billing: optional3(boolean2())
   }),
   z79.transform((v) => {
     return remap(v, {
       "feature_id": "featureId",
       "limit_type": "limitType",
-      "overage_limit": "overageLimit"
+      "overage_limit": "overageLimit",
+      "skip_overage_billing": "skipOverageBilling"
     });
   })
 );
 var UpdatePlanUsageLimitIntervalResponse$inboundSchema = inboundSchema(UpdatePlanUsageLimitIntervalResponse);
+var UpdatePlanFilterResponse$inboundSchema = z79.object({
+  properties: z79.record(z79.string(), z79.any())
+});
 var UpdatePlanUsageLimitResponse$inboundSchema = z79.pipe(
   z79.object({
     feature_id: string4(),
     enabled: z79._default(boolean2(), true),
     limit: number2(),
-    interval: UpdatePlanUsageLimitIntervalResponse$inboundSchema
+    interval: UpdatePlanUsageLimitIntervalResponse$inboundSchema,
+    filter: optional3(
+      z79.lazy(() => UpdatePlanFilterResponse$inboundSchema)
+    )
   }),
   z79.transform((v) => {
     return remap(v, {
@@ -26490,7 +27039,7 @@ var Billing = class extends ClientSDK {
    * @example
    * ```typescript
    * // Schedule a transition from a trial plan to a paid plan
-   * const response = await client.billing.createSchedule({ customerId: "cus_123", phases: [{"startsAt":1783265198891,"plans":[{"planId":"trial_plan"}]},{"startsAt":1784474798891,"plans":[{"planId":"pro_plan"}]}] });
+   * const response = await client.billing.createSchedule({ customerId: "cus_123", phases: [{"startsAt":1783539171816,"plans":[{"planId":"trial_plan"}]},{"startsAt":1784748771816,"plans":[{"planId":"pro_plan"}]}] });
    * ```
    *
    * @param customerId - The ID of the customer to create the schedule for.
@@ -26675,6 +27224,7 @@ var Billing = class extends ClientSDK {
    * @param cancelAction - Action to perform for cancellation. 'cancel_immediately' cancels now with prorated refund, 'cancel_end_of_cycle' cancels at period end, 'uncancel' reverses a pending cancellation. (optional)
    * @param billingCycleAnchor - Reset the billing cycle anchor immediately with 'now' (optional)
    * @param noBillingChanges - If true, the subscription is updated internally without applying billing changes in Stripe. (optional)
+   * @param refundLastPayment - Controls how the last payment is refunded on immediate cancellation. 'prorated' refunds the unused portion, 'full' refunds the entire last payment. (optional)
    * @param recalculateBalances - Controls whether balances should be recalculated during the subscription update. (optional)
    * @param carryOverUsages - Whether to carry over usages from the previous plan. (optional)
    *
@@ -26712,6 +27262,7 @@ var Billing = class extends ClientSDK {
    * @param cancelAction - Action to perform for cancellation. 'cancel_immediately' cancels now with prorated refund, 'cancel_end_of_cycle' cancels at period end, 'uncancel' reverses a pending cancellation. (optional)
    * @param billingCycleAnchor - Reset the billing cycle anchor immediately with 'now' (optional)
    * @param noBillingChanges - If true, the subscription is updated internally without applying billing changes in Stripe. (optional)
+   * @param refundLastPayment - Controls how the last payment is refunded on immediate cancellation. 'prorated' refunds the unused portion, 'full' refunds the entire last payment. (optional)
    * @param recalculateBalances - Controls whether balances should be recalculated during the subscription update. (optional)
    * @param carryOverUsages - Whether to carry over usages from the previous plan. (optional)
    *