@polar-sh/sdk 0.33.2 → 0.34.1

package/src/models/components/meter.ts

@@ -32,11 +32,11 @@ export type MeterMetadata = string | number | number | boolean;
  * The aggregation to apply on the filtered events to calculate the meter.
  */
 export type MeterAggregation =
+  | (CountAggregation & { func: "count" })
   | (PropertyAggregation & { func: "avg" })
-  | (PropertyAggregation & { func: "avg" })
-  | (PropertyAggregation & { func: "avg" })
-  | (PropertyAggregation & { func: "avg" })
-  | (CountAggregation & { func: "count" });
+  | (PropertyAggregation & { func: "max" })
+  | (PropertyAggregation & { func: "min" })
+  | (PropertyAggregation & { func: "sum" });
 
 export type Meter = {
   metadata: { [k: string]: string | number | number | boolean };
@@ -61,11 +61,11 @@ export type Meter = {
    * The aggregation to apply on the filtered events to calculate the meter.
    */
   aggregation:
+    | (CountAggregation & { func: "count" })
     | (PropertyAggregation & { func: "avg" })
-    | (PropertyAggregation & { func: "avg" })
-    | (PropertyAggregation & { func: "avg" })
-    | (PropertyAggregation & { func: "avg" })
-    | (CountAggregation & { func: "count" });
+    | (PropertyAggregation & { func: "max" })
+    | (PropertyAggregation & { func: "min" })
+    | (PropertyAggregation & { func: "sum" });
   /**
    * The ID of the organization owning the meter.
    */
@@ -122,30 +122,30 @@ export const MeterAggregation$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  PropertyAggregation$inboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+  CountAggregation$inboundSchema.and(
+    z.object({ func: z.literal("count") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$inboundSchema.and(
     z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$inboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+    z.object({ func: z.literal("max") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$inboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+    z.object({ func: z.literal("min") }).transform((v) => ({ func: v.func })),
   ),
-  CountAggregation$inboundSchema.and(
-    z.object({ func: z.literal("count") }).transform((v) => ({ func: v.func })),
+  PropertyAggregation$inboundSchema.and(
+    z.object({ func: z.literal("sum") }).transform((v) => ({ func: v.func })),
   ),
 ]);
 
 /** @internal */
 export type MeterAggregation$Outbound =
+  | (CountAggregation$Outbound & { func: "count" })
   | (PropertyAggregation$Outbound & { func: "avg" })
-  | (PropertyAggregation$Outbound & { func: "avg" })
-  | (PropertyAggregation$Outbound & { func: "avg" })
-  | (PropertyAggregation$Outbound & { func: "avg" })
-  | (CountAggregation$Outbound & { func: "count" });
+  | (PropertyAggregation$Outbound & { func: "max" })
+  | (PropertyAggregation$Outbound & { func: "min" })
+  | (PropertyAggregation$Outbound & { func: "sum" });
 
 /** @internal */
 export const MeterAggregation$outboundSchema: z.ZodType<
@@ -153,20 +153,20 @@ export const MeterAggregation$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   MeterAggregation
 > = z.union([
-  PropertyAggregation$outboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+  CountAggregation$outboundSchema.and(
+    z.object({ func: z.literal("count") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$outboundSchema.and(
     z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$outboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+    z.object({ func: z.literal("max") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$outboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+    z.object({ func: z.literal("min") }).transform((v) => ({ func: v.func })),
   ),
-  CountAggregation$outboundSchema.and(
-    z.object({ func: z.literal("count") }).transform((v) => ({ func: v.func })),
+  PropertyAggregation$outboundSchema.and(
+    z.object({ func: z.literal("sum") }).transform((v) => ({ func: v.func })),
   ),
 ]);
 
@@ -217,8 +217,8 @@ export const Meter$inboundSchema: z.ZodType<Meter, z.ZodTypeDef, unknown> = z
     name: z.string(),
     filter: Filter$inboundSchema,
     aggregation: z.union([
-      PropertyAggregation$inboundSchema.and(
-        z.object({ func: z.literal("avg") }).transform((v) => ({
+      CountAggregation$inboundSchema.and(
+        z.object({ func: z.literal("count") }).transform((v) => ({
           func: v.func,
         })),
       ),
@@ -228,17 +228,17 @@ export const Meter$inboundSchema: z.ZodType<Meter, z.ZodTypeDef, unknown> = z
         })),
       ),
       PropertyAggregation$inboundSchema.and(
-        z.object({ func: z.literal("avg") }).transform((v) => ({
+        z.object({ func: z.literal("max") }).transform((v) => ({
           func: v.func,
         })),
       ),
       PropertyAggregation$inboundSchema.and(
-        z.object({ func: z.literal("avg") }).transform((v) => ({
+        z.object({ func: z.literal("min") }).transform((v) => ({
           func: v.func,
         })),
       ),
-      CountAggregation$inboundSchema.and(
-        z.object({ func: z.literal("count") }).transform((v) => ({
+      PropertyAggregation$inboundSchema.and(
+        z.object({ func: z.literal("sum") }).transform((v) => ({
           func: v.func,
         })),
       ),
@@ -261,11 +261,11 @@ export type Meter$Outbound = {
   name: string;
   filter: Filter$Outbound;
   aggregation:
+    | (CountAggregation$Outbound & { func: "count" })
     | (PropertyAggregation$Outbound & { func: "avg" })
-    | (PropertyAggregation$Outbound & { func: "avg" })
-    | (PropertyAggregation$Outbound & { func: "avg" })
-    | (PropertyAggregation$Outbound & { func: "avg" })
-    | (CountAggregation$Outbound & { func: "count" });
+    | (PropertyAggregation$Outbound & { func: "max" })
+    | (PropertyAggregation$Outbound & { func: "min" })
+    | (PropertyAggregation$Outbound & { func: "sum" });
   organization_id: string;
 };
 
@@ -284,22 +284,22 @@ export const Meter$outboundSchema: z.ZodType<
   name: z.string(),
   filter: Filter$outboundSchema,
   aggregation: z.union([
-    PropertyAggregation$outboundSchema.and(
-      z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+    CountAggregation$outboundSchema.and(
+      z.object({ func: z.literal("count") }).transform((v) => ({
+        func: v.func,
+      })),
     ),
     PropertyAggregation$outboundSchema.and(
       z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
     ),
     PropertyAggregation$outboundSchema.and(
-      z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+      z.object({ func: z.literal("max") }).transform((v) => ({ func: v.func })),
     ),
     PropertyAggregation$outboundSchema.and(
-      z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+      z.object({ func: z.literal("min") }).transform((v) => ({ func: v.func })),
     ),
-    CountAggregation$outboundSchema.and(
-      z.object({ func: z.literal("count") }).transform((v) => ({
-        func: v.func,
-      })),
+    PropertyAggregation$outboundSchema.and(
+      z.object({ func: z.literal("sum") }).transform((v) => ({ func: v.func })),
     ),
   ]),
   organizationId: z.string(),

package/src/models/components/metercreate.ts

@@ -32,11 +32,11 @@ export type MeterCreateMetadata = string | number | number | boolean;
  * The aggregation to apply on the filtered events to calculate the meter.
  */
 export type MeterCreateAggregation =
+  | (CountAggregation & { func: "count" })
   | (PropertyAggregation & { func: "avg" })
-  | (PropertyAggregation & { func: "avg" })
-  | (PropertyAggregation & { func: "avg" })
-  | (PropertyAggregation & { func: "avg" })
-  | (CountAggregation & { func: "count" });
+  | (PropertyAggregation & { func: "max" })
+  | (PropertyAggregation & { func: "min" })
+  | (PropertyAggregation & { func: "sum" });
 
 export type MeterCreate = {
   /**
@@ -64,11 +64,11 @@ export type MeterCreate = {
    * The aggregation to apply on the filtered events to calculate the meter.
    */
   aggregation:
+    | (CountAggregation & { func: "count" })
     | (PropertyAggregation & { func: "avg" })
-    | (PropertyAggregation & { func: "avg" })
-    | (PropertyAggregation & { func: "avg" })
-    | (PropertyAggregation & { func: "avg" })
-    | (CountAggregation & { func: "count" });
+    | (PropertyAggregation & { func: "max" })
+    | (PropertyAggregation & { func: "min" })
+    | (PropertyAggregation & { func: "sum" });
   /**
    * The ID of the organization owning the meter. **Required unless you use an organization token.**
    */
@@ -129,30 +129,30 @@ export const MeterCreateAggregation$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  PropertyAggregation$inboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+  CountAggregation$inboundSchema.and(
+    z.object({ func: z.literal("count") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$inboundSchema.and(
     z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$inboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+    z.object({ func: z.literal("max") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$inboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+    z.object({ func: z.literal("min") }).transform((v) => ({ func: v.func })),
   ),
-  CountAggregation$inboundSchema.and(
-    z.object({ func: z.literal("count") }).transform((v) => ({ func: v.func })),
+  PropertyAggregation$inboundSchema.and(
+    z.object({ func: z.literal("sum") }).transform((v) => ({ func: v.func })),
   ),
 ]);
 
 /** @internal */
 export type MeterCreateAggregation$Outbound =
+  | (CountAggregation$Outbound & { func: "count" })
   | (PropertyAggregation$Outbound & { func: "avg" })
-  | (PropertyAggregation$Outbound & { func: "avg" })
-  | (PropertyAggregation$Outbound & { func: "avg" })
-  | (PropertyAggregation$Outbound & { func: "avg" })
-  | (CountAggregation$Outbound & { func: "count" });
+  | (PropertyAggregation$Outbound & { func: "max" })
+  | (PropertyAggregation$Outbound & { func: "min" })
+  | (PropertyAggregation$Outbound & { func: "sum" });
 
 /** @internal */
 export const MeterCreateAggregation$outboundSchema: z.ZodType<
@@ -160,20 +160,20 @@ export const MeterCreateAggregation$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   MeterCreateAggregation
 > = z.union([
-  PropertyAggregation$outboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+  CountAggregation$outboundSchema.and(
+    z.object({ func: z.literal("count") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$outboundSchema.and(
     z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$outboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+    z.object({ func: z.literal("max") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$outboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+    z.object({ func: z.literal("min") }).transform((v) => ({ func: v.func })),
   ),
-  CountAggregation$outboundSchema.and(
-    z.object({ func: z.literal("count") }).transform((v) => ({ func: v.func })),
+  PropertyAggregation$outboundSchema.and(
+    z.object({ func: z.literal("sum") }).transform((v) => ({ func: v.func })),
   ),
 ]);
 
@@ -220,22 +220,22 @@ export const MeterCreate$inboundSchema: z.ZodType<
   name: z.string(),
   filter: Filter$inboundSchema,
   aggregation: z.union([
-    PropertyAggregation$inboundSchema.and(
-      z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+    CountAggregation$inboundSchema.and(
+      z.object({ func: z.literal("count") }).transform((v) => ({
+        func: v.func,
+      })),
     ),
     PropertyAggregation$inboundSchema.and(
       z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
     ),
     PropertyAggregation$inboundSchema.and(
-      z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+      z.object({ func: z.literal("max") }).transform((v) => ({ func: v.func })),
     ),
     PropertyAggregation$inboundSchema.and(
-      z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+      z.object({ func: z.literal("min") }).transform((v) => ({ func: v.func })),
     ),
-    CountAggregation$inboundSchema.and(
-      z.object({ func: z.literal("count") }).transform((v) => ({
-        func: v.func,
-      })),
+    PropertyAggregation$inboundSchema.and(
+      z.object({ func: z.literal("sum") }).transform((v) => ({ func: v.func })),
     ),
   ]),
   organization_id: z.nullable(z.string()).optional(),
@@ -251,11 +251,11 @@ export type MeterCreate$Outbound = {
   name: string;
   filter: Filter$Outbound;
   aggregation:
+    | (CountAggregation$Outbound & { func: "count" })
     | (PropertyAggregation$Outbound & { func: "avg" })
-    | (PropertyAggregation$Outbound & { func: "avg" })
-    | (PropertyAggregation$Outbound & { func: "avg" })
-    | (PropertyAggregation$Outbound & { func: "avg" })
-    | (CountAggregation$Outbound & { func: "count" });
+    | (PropertyAggregation$Outbound & { func: "max" })
+    | (PropertyAggregation$Outbound & { func: "min" })
+    | (PropertyAggregation$Outbound & { func: "sum" });
   organization_id?: string | null | undefined;
 };
 
@@ -271,22 +271,22 @@ export const MeterCreate$outboundSchema: z.ZodType<
   name: z.string(),
   filter: Filter$outboundSchema,
   aggregation: z.union([
-    PropertyAggregation$outboundSchema.and(
-      z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+    CountAggregation$outboundSchema.and(
+      z.object({ func: z.literal("count") }).transform((v) => ({
+        func: v.func,
+      })),
     ),
     PropertyAggregation$outboundSchema.and(
       z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
     ),
     PropertyAggregation$outboundSchema.and(
-      z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+      z.object({ func: z.literal("max") }).transform((v) => ({ func: v.func })),
     ),
     PropertyAggregation$outboundSchema.and(
-      z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+      z.object({ func: z.literal("min") }).transform((v) => ({ func: v.func })),
     ),
-    CountAggregation$outboundSchema.and(
-      z.object({ func: z.literal("count") }).transform((v) => ({
-        func: v.func,
-      })),
+    PropertyAggregation$outboundSchema.and(
+      z.object({ func: z.literal("sum") }).transform((v) => ({ func: v.func })),
     ),
   ]),
   organizationId: z.nullable(z.string()).optional(),

package/src/models/components/meterupdate.ts

@@ -28,11 +28,11 @@ import {
 export type MeterUpdateMetadata = string | number | number | boolean;
 
 export type Aggregation =
+  | (CountAggregation & { func: "count" })
   | (PropertyAggregation & { func: "avg" })
-  | (PropertyAggregation & { func: "avg" })
-  | (PropertyAggregation & { func: "avg" })
-  | (PropertyAggregation & { func: "avg" })
-  | (CountAggregation & { func: "count" });
+  | (PropertyAggregation & { func: "max" })
+  | (PropertyAggregation & { func: "min" })
+  | (PropertyAggregation & { func: "sum" });
 
 export type MeterUpdate = {
   /**
@@ -63,11 +63,11 @@ export type MeterUpdate = {
    * The aggregation to apply on the filtered events to calculate the meter.
    */
   aggregation?:
-    | (PropertyAggregation & { func: "avg" })
-    | (PropertyAggregation & { func: "avg" })
-    | (PropertyAggregation & { func: "avg" })
-    | (PropertyAggregation & { func: "avg" })
     | (CountAggregation & { func: "count" })
+    | (PropertyAggregation & { func: "avg" })
+    | (PropertyAggregation & { func: "max" })
+    | (PropertyAggregation & { func: "min" })
+    | (PropertyAggregation & { func: "sum" })
     | null
     | undefined;
 };
@@ -126,30 +126,30 @@ export const Aggregation$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  PropertyAggregation$inboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+  CountAggregation$inboundSchema.and(
+    z.object({ func: z.literal("count") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$inboundSchema.and(
     z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$inboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+    z.object({ func: z.literal("max") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$inboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+    z.object({ func: z.literal("min") }).transform((v) => ({ func: v.func })),
   ),
-  CountAggregation$inboundSchema.and(
-    z.object({ func: z.literal("count") }).transform((v) => ({ func: v.func })),
+  PropertyAggregation$inboundSchema.and(
+    z.object({ func: z.literal("sum") }).transform((v) => ({ func: v.func })),
   ),
 ]);
 
 /** @internal */
 export type Aggregation$Outbound =
+  | (CountAggregation$Outbound & { func: "count" })
   | (PropertyAggregation$Outbound & { func: "avg" })
-  | (PropertyAggregation$Outbound & { func: "avg" })
-  | (PropertyAggregation$Outbound & { func: "avg" })
-  | (PropertyAggregation$Outbound & { func: "avg" })
-  | (CountAggregation$Outbound & { func: "count" });
+  | (PropertyAggregation$Outbound & { func: "max" })
+  | (PropertyAggregation$Outbound & { func: "min" })
+  | (PropertyAggregation$Outbound & { func: "sum" });
 
 /** @internal */
 export const Aggregation$outboundSchema: z.ZodType<
@@ -157,20 +157,20 @@ export const Aggregation$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Aggregation
 > = z.union([
-  PropertyAggregation$outboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+  CountAggregation$outboundSchema.and(
+    z.object({ func: z.literal("count") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$outboundSchema.and(
     z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$outboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+    z.object({ func: z.literal("max") }).transform((v) => ({ func: v.func })),
   ),
   PropertyAggregation$outboundSchema.and(
-    z.object({ func: z.literal("avg") }).transform((v) => ({ func: v.func })),
+    z.object({ func: z.literal("min") }).transform((v) => ({ func: v.func })),
   ),
-  CountAggregation$outboundSchema.and(
-    z.object({ func: z.literal("count") }).transform((v) => ({ func: v.func })),
+  PropertyAggregation$outboundSchema.and(
+    z.object({ func: z.literal("sum") }).transform((v) => ({ func: v.func })),
   ),
 ]);
 
@@ -214,8 +214,8 @@ export const MeterUpdate$inboundSchema: z.ZodType<
   filter: z.nullable(Filter$inboundSchema).optional(),
   aggregation: z.nullable(
     z.union([
-      PropertyAggregation$inboundSchema.and(
-        z.object({ func: z.literal("avg") }).transform((v) => ({
+      CountAggregation$inboundSchema.and(
+        z.object({ func: z.literal("count") }).transform((v) => ({
           func: v.func,
         })),
       ),
@@ -225,17 +225,17 @@ export const MeterUpdate$inboundSchema: z.ZodType<
         })),
       ),
       PropertyAggregation$inboundSchema.and(
-        z.object({ func: z.literal("avg") }).transform((v) => ({
+        z.object({ func: z.literal("max") }).transform((v) => ({
           func: v.func,
         })),
       ),
       PropertyAggregation$inboundSchema.and(
-        z.object({ func: z.literal("avg") }).transform((v) => ({
+        z.object({ func: z.literal("min") }).transform((v) => ({
           func: v.func,
         })),
       ),
-      CountAggregation$inboundSchema.and(
-        z.object({ func: z.literal("count") }).transform((v) => ({
+      PropertyAggregation$inboundSchema.and(
+        z.object({ func: z.literal("sum") }).transform((v) => ({
           func: v.func,
         })),
       ),
@@ -249,11 +249,11 @@ export type MeterUpdate$Outbound = {
   name?: string | null | undefined;
   filter?: Filter$Outbound | null | undefined;
   aggregation?:
-    | (PropertyAggregation$Outbound & { func: "avg" })
-    | (PropertyAggregation$Outbound & { func: "avg" })
-    | (PropertyAggregation$Outbound & { func: "avg" })
-    | (PropertyAggregation$Outbound & { func: "avg" })
     | (CountAggregation$Outbound & { func: "count" })
+    | (PropertyAggregation$Outbound & { func: "avg" })
+    | (PropertyAggregation$Outbound & { func: "max" })
+    | (PropertyAggregation$Outbound & { func: "min" })
+    | (PropertyAggregation$Outbound & { func: "sum" })
     | null
     | undefined;
 };
@@ -271,8 +271,8 @@ export const MeterUpdate$outboundSchema: z.ZodType<
   filter: z.nullable(Filter$outboundSchema).optional(),
   aggregation: z.nullable(
     z.union([
-      PropertyAggregation$outboundSchema.and(
-        z.object({ func: z.literal("avg") }).transform((v) => ({
+      CountAggregation$outboundSchema.and(
+        z.object({ func: z.literal("count") }).transform((v) => ({
           func: v.func,
         })),
       ),
@@ -282,17 +282,17 @@ export const MeterUpdate$outboundSchema: z.ZodType<
         })),
       ),
       PropertyAggregation$outboundSchema.and(
-        z.object({ func: z.literal("avg") }).transform((v) => ({
+        z.object({ func: z.literal("max") }).transform((v) => ({
           func: v.func,
         })),
       ),
       PropertyAggregation$outboundSchema.and(
-        z.object({ func: z.literal("avg") }).transform((v) => ({
+        z.object({ func: z.literal("min") }).transform((v) => ({
           func: v.func,
         })),
       ),
-      CountAggregation$outboundSchema.and(
-        z.object({ func: z.literal("count") }).transform((v) => ({
+      PropertyAggregation$outboundSchema.and(
+        z.object({ func: z.literal("sum") }).transform((v) => ({
           func: v.func,
         })),
       ),

package/src/models/components/order.ts

@@ -77,10 +77,10 @@ export type OrderMetadata = string | number | number | boolean;
 export type OrderCustomFieldData = string | number | boolean | Date;
 
 export type OrderDiscount =
-  | DiscountFixedRepeatDurationBase
+  | DiscountPercentageOnceForeverDurationBase
   | DiscountFixedOnceForeverDurationBase
   | DiscountPercentageRepeatDurationBase
-  | DiscountPercentageOnceForeverDurationBase;
+  | DiscountFixedRepeatDurationBase;
 
 export type Order = {
   /**
@@ -164,10 +164,10 @@ export type Order = {
   userId: string;
   product: OrderProduct;
   discount:
-    | DiscountFixedRepeatDurationBase
+    | DiscountPercentageOnceForeverDurationBase
     | DiscountFixedOnceForeverDurationBase
     | DiscountPercentageRepeatDurationBase
-    | DiscountPercentageOnceForeverDurationBase
+    | DiscountFixedRepeatDurationBase
     | null;
   subscription: OrderSubscription | null;
   /**
@@ -284,18 +284,18 @@ export const OrderDiscount$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  DiscountFixedRepeatDurationBase$inboundSchema,
+  DiscountPercentageOnceForeverDurationBase$inboundSchema,
   DiscountFixedOnceForeverDurationBase$inboundSchema,
   DiscountPercentageRepeatDurationBase$inboundSchema,
-  DiscountPercentageOnceForeverDurationBase$inboundSchema,
+  DiscountFixedRepeatDurationBase$inboundSchema,
 ]);
 
 /** @internal */
 export type OrderDiscount$Outbound =
-  | DiscountFixedRepeatDurationBase$Outbound
+  | DiscountPercentageOnceForeverDurationBase$Outbound
   | DiscountFixedOnceForeverDurationBase$Outbound
   | DiscountPercentageRepeatDurationBase$Outbound
-  | DiscountPercentageOnceForeverDurationBase$Outbound;
+  | DiscountFixedRepeatDurationBase$Outbound;
 
 /** @internal */
 export const OrderDiscount$outboundSchema: z.ZodType<
@@ -303,10 +303,10 @@ export const OrderDiscount$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   OrderDiscount
 > = z.union([
-  DiscountFixedRepeatDurationBase$outboundSchema,
+  DiscountPercentageOnceForeverDurationBase$outboundSchema,
   DiscountFixedOnceForeverDurationBase$outboundSchema,
   DiscountPercentageRepeatDurationBase$outboundSchema,
-  DiscountPercentageOnceForeverDurationBase$outboundSchema,
+  DiscountFixedRepeatDurationBase$outboundSchema,
 ]);
 
 /**
@@ -384,10 +384,10 @@ export const Order$inboundSchema: z.ZodType<Order, z.ZodTypeDef, unknown> = z
     product: OrderProduct$inboundSchema,
     discount: z.nullable(
       z.union([
-        DiscountFixedRepeatDurationBase$inboundSchema,
+        DiscountPercentageOnceForeverDurationBase$inboundSchema,
         DiscountFixedOnceForeverDurationBase$inboundSchema,
         DiscountPercentageRepeatDurationBase$inboundSchema,
-        DiscountPercentageOnceForeverDurationBase$inboundSchema,
+        DiscountFixedRepeatDurationBase$inboundSchema,
       ]),
     ),
     subscription: z.nullable(OrderSubscription$inboundSchema),
@@ -450,10 +450,10 @@ export type Order$Outbound = {
   user_id: string;
   product: OrderProduct$Outbound;
   discount:
-    | DiscountFixedRepeatDurationBase$Outbound
+    | DiscountPercentageOnceForeverDurationBase$Outbound
     | DiscountFixedOnceForeverDurationBase$Outbound
     | DiscountPercentageRepeatDurationBase$Outbound
-    | DiscountPercentageOnceForeverDurationBase$Outbound
+    | DiscountFixedRepeatDurationBase$Outbound
     | null;
   subscription: OrderSubscription$Outbound | null;
   items: Array<OrderItemSchema$Outbound>;
@@ -506,10 +506,10 @@ export const Order$outboundSchema: z.ZodType<
   product: OrderProduct$outboundSchema,
   discount: z.nullable(
     z.union([
-      DiscountFixedRepeatDurationBase$outboundSchema,
+      DiscountPercentageOnceForeverDurationBase$outboundSchema,
       DiscountFixedOnceForeverDurationBase$outboundSchema,
       DiscountPercentageRepeatDurationBase$outboundSchema,
-      DiscountPercentageOnceForeverDurationBase$outboundSchema,
+      DiscountFixedRepeatDurationBase$outboundSchema,
     ]),
   ),
   subscription: z.nullable(OrderSubscription$outboundSchema),

package/src/models/components/payment.ts

@@ -19,21 +19,21 @@ import {
   GenericPayment$outboundSchema,
 } from "./genericpayment.js";
 
-export type Payment = CardPayment | GenericPayment;
+export type Payment = GenericPayment | CardPayment;
 
 /** @internal */
 export const Payment$inboundSchema: z.ZodType<Payment, z.ZodTypeDef, unknown> =
-  z.union([CardPayment$inboundSchema, GenericPayment$inboundSchema]);
+  z.union([GenericPayment$inboundSchema, CardPayment$inboundSchema]);
 
 /** @internal */
-export type Payment$Outbound = CardPayment$Outbound | GenericPayment$Outbound;
+export type Payment$Outbound = GenericPayment$Outbound | CardPayment$Outbound;
 
 /** @internal */
 export const Payment$outboundSchema: z.ZodType<
   Payment$Outbound,
   z.ZodTypeDef,
   Payment
-> = z.union([CardPayment$outboundSchema, GenericPayment$outboundSchema]);
+> = z.union([GenericPayment$outboundSchema, CardPayment$outboundSchema]);
 
 /**
  * @internal