@meetkai/mka1 0.53.30 → 0.53.31

package/src/models/operations/listbudgets.ts

@@ -9,43 +9,97 @@ import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export const ListBudgetsScope = {
+export const DataScope = {
   Org: "org",
   Apikey: "apikey",
+  User: "user",
+  Team: "team",
+  ExternalUser: "external_user",
+  UserDefault: "user_default",
+  TeamDefault: "team_default",
+  ExternalUserDefault: "external_user_default",
 } as const;
-export type ListBudgetsScope = ClosedEnum<typeof ListBudgetsScope>;
+export type DataScope = ClosedEnum<typeof DataScope>;
 
-export const ListBudgetsOwner = {
+export const DataOwner = {
   Cluster: "cluster",
   Org: "org",
 } as const;
-export type ListBudgetsOwner = ClosedEnum<typeof ListBudgetsOwner>;
+export type DataOwner = ClosedEnum<typeof DataOwner>;
 
-export const ListBudgetsPeriod = {
+export const DataPeriod = {
   Daily: "daily",
   Weekly: "weekly",
   Monthly: "monthly",
 } as const;
-export type ListBudgetsPeriod = ClosedEnum<typeof ListBudgetsPeriod>;
+export type DataPeriod = ClosedEnum<typeof DataPeriod>;
 
-export const ListBudgetsAction = {
+export const DataAction = {
   Alert: "alert",
   Block: "block",
 } as const;
-export type ListBudgetsAction = ClosedEnum<typeof ListBudgetsAction>;
+export type DataAction = ClosedEnum<typeof DataAction>;
 
-export type ListBudgetsThresholds = {
+export type DataThresholds = {
   pct: number;
-  action: ListBudgetsAction;
+  action: DataAction;
 };
 
-export const ListBudgetsStatus = {
+export type Data2 = {
+  id: string;
+  scope: DataScope;
+  scopeId: string;
+  scopeOrgId: string | null;
+  owner: DataOwner;
+  period: DataPeriod;
+  limit: number;
+  thresholds: Array<DataThresholds>;
+  alertWebhookUrl: string | null;
+};
+
+export const ListBudgetsDataScope = {
+  Org: "org",
+  Apikey: "apikey",
+  User: "user",
+  Team: "team",
+  ExternalUser: "external_user",
+  UserDefault: "user_default",
+  TeamDefault: "team_default",
+  ExternalUserDefault: "external_user_default",
+} as const;
+export type ListBudgetsDataScope = ClosedEnum<typeof ListBudgetsDataScope>;
+
+export const ListBudgetsDataOwner = {
+  Cluster: "cluster",
+  Org: "org",
+} as const;
+export type ListBudgetsDataOwner = ClosedEnum<typeof ListBudgetsDataOwner>;
+
+export const ListBudgetsDataPeriod = {
+  Daily: "daily",
+  Weekly: "weekly",
+  Monthly: "monthly",
+} as const;
+export type ListBudgetsDataPeriod = ClosedEnum<typeof ListBudgetsDataPeriod>;
+
+export const ListBudgetsDataAction = {
+  Alert: "alert",
+  Block: "block",
+} as const;
+export type ListBudgetsDataAction = ClosedEnum<typeof ListBudgetsDataAction>;
+
+export type ListBudgetsDataThresholds = {
+  pct: number;
+  action: ListBudgetsDataAction;
+};
+
+export const DataStatus = {
   Ok: "ok",
   Blocked: "blocked",
 } as const;
-export type ListBudgetsStatus = ClosedEnum<typeof ListBudgetsStatus>;
+export type DataStatus = ClosedEnum<typeof DataStatus>;
 
-export type ListBudgetsSpend = {
+export type DataSpend = {
   /**
    * Current period bucket, e.g. 2026-07 / 2026-W28 / 2026-07-07
    */
@@ -56,120 +110,254 @@ export type ListBudgetsSpend = {
   costSpent: number;
   limit: number;
   pct: number;
-  status: ListBudgetsStatus;
+  status: DataStatus;
 };
 
-export type ListBudgetsData = {
+export type Data1 = {
   id: string;
-  scope: ListBudgetsScope;
+  scope: ListBudgetsDataScope;
   scopeId: string;
   scopeOrgId: string | null;
-  owner: ListBudgetsOwner;
-  period: ListBudgetsPeriod;
+  owner: ListBudgetsDataOwner;
+  period: ListBudgetsDataPeriod;
   limit: number;
-  thresholds: Array<ListBudgetsThresholds>;
+  thresholds: Array<ListBudgetsDataThresholds>;
   alertWebhookUrl: string | null;
-  spend: ListBudgetsSpend;
+  spend: DataSpend;
 };
 
+export type ListBudgetsData = Data1 | Data2;
+
 /**
  * OK
  */
 export type ListBudgetsResponseBody = {
   object: "list";
-  data: Array<ListBudgetsData>;
+  data: Array<Data1 | Data2>;
+};
+
+/** @internal */
+export const DataScope$inboundSchema: z.ZodNativeEnum<typeof DataScope> = z
+  .nativeEnum(DataScope);
+/** @internal */
+export const DataScope$outboundSchema: z.ZodNativeEnum<typeof DataScope> =
+  DataScope$inboundSchema;
+
+/** @internal */
+export const DataOwner$inboundSchema: z.ZodNativeEnum<typeof DataOwner> = z
+  .nativeEnum(DataOwner);
+/** @internal */
+export const DataOwner$outboundSchema: z.ZodNativeEnum<typeof DataOwner> =
+  DataOwner$inboundSchema;
+
+/** @internal */
+export const DataPeriod$inboundSchema: z.ZodNativeEnum<typeof DataPeriod> = z
+  .nativeEnum(DataPeriod);
+/** @internal */
+export const DataPeriod$outboundSchema: z.ZodNativeEnum<typeof DataPeriod> =
+  DataPeriod$inboundSchema;
+
+/** @internal */
+export const DataAction$inboundSchema: z.ZodNativeEnum<typeof DataAction> = z
+  .nativeEnum(DataAction);
+/** @internal */
+export const DataAction$outboundSchema: z.ZodNativeEnum<typeof DataAction> =
+  DataAction$inboundSchema;
+
+/** @internal */
+export const DataThresholds$inboundSchema: z.ZodType<
+  DataThresholds,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  pct: z.number().int(),
+  action: DataAction$inboundSchema,
+});
+/** @internal */
+export type DataThresholds$Outbound = {
+  pct: number;
+  action: string;
+};
+
+/** @internal */
+export const DataThresholds$outboundSchema: z.ZodType<
+  DataThresholds$Outbound,
+  z.ZodTypeDef,
+  DataThresholds
+> = z.object({
+  pct: z.number().int(),
+  action: DataAction$outboundSchema,
+});
+
+export function dataThresholdsToJSON(dataThresholds: DataThresholds): string {
+  return JSON.stringify(DataThresholds$outboundSchema.parse(dataThresholds));
+}
+export function dataThresholdsFromJSON(
+  jsonString: string,
+): SafeParseResult<DataThresholds, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DataThresholds$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DataThresholds' from JSON`,
+  );
+}
+
+/** @internal */
+export const Data2$inboundSchema: z.ZodType<Data2, z.ZodTypeDef, unknown> = z
+  .object({
+    id: z.string(),
+    scope: DataScope$inboundSchema,
+    scope_id: z.string(),
+    scope_org_id: z.nullable(z.string()),
+    owner: DataOwner$inboundSchema,
+    period: DataPeriod$inboundSchema,
+    limit: z.number(),
+    thresholds: z.array(z.lazy(() => DataThresholds$inboundSchema)),
+    alert_webhook_url: z.nullable(z.string()),
+  }).transform((v) => {
+    return remap$(v, {
+      "scope_id": "scopeId",
+      "scope_org_id": "scopeOrgId",
+      "alert_webhook_url": "alertWebhookUrl",
+    });
+  });
+/** @internal */
+export type Data2$Outbound = {
+  id: string;
+  scope: string;
+  scope_id: string;
+  scope_org_id: string | null;
+  owner: string;
+  period: string;
+  limit: number;
+  thresholds: Array<DataThresholds$Outbound>;
+  alert_webhook_url: string | null;
 };
 
 /** @internal */
-export const ListBudgetsScope$inboundSchema: z.ZodNativeEnum<
-  typeof ListBudgetsScope
-> = z.nativeEnum(ListBudgetsScope);
+export const Data2$outboundSchema: z.ZodType<
+  Data2$Outbound,
+  z.ZodTypeDef,
+  Data2
+> = z.object({
+  id: z.string(),
+  scope: DataScope$outboundSchema,
+  scopeId: z.string(),
+  scopeOrgId: z.nullable(z.string()),
+  owner: DataOwner$outboundSchema,
+  period: DataPeriod$outboundSchema,
+  limit: z.number(),
+  thresholds: z.array(z.lazy(() => DataThresholds$outboundSchema)),
+  alertWebhookUrl: z.nullable(z.string()),
+}).transform((v) => {
+  return remap$(v, {
+    scopeId: "scope_id",
+    scopeOrgId: "scope_org_id",
+    alertWebhookUrl: "alert_webhook_url",
+  });
+});
+
+export function data2ToJSON(data2: Data2): string {
+  return JSON.stringify(Data2$outboundSchema.parse(data2));
+}
+export function data2FromJSON(
+  jsonString: string,
+): SafeParseResult<Data2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Data2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Data2' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListBudgetsDataScope$inboundSchema: z.ZodNativeEnum<
+  typeof ListBudgetsDataScope
+> = z.nativeEnum(ListBudgetsDataScope);
 /** @internal */
-export const ListBudgetsScope$outboundSchema: z.ZodNativeEnum<
-  typeof ListBudgetsScope
-> = ListBudgetsScope$inboundSchema;
+export const ListBudgetsDataScope$outboundSchema: z.ZodNativeEnum<
+  typeof ListBudgetsDataScope
+> = ListBudgetsDataScope$inboundSchema;
 
 /** @internal */
-export const ListBudgetsOwner$inboundSchema: z.ZodNativeEnum<
-  typeof ListBudgetsOwner
-> = z.nativeEnum(ListBudgetsOwner);
+export const ListBudgetsDataOwner$inboundSchema: z.ZodNativeEnum<
+  typeof ListBudgetsDataOwner
+> = z.nativeEnum(ListBudgetsDataOwner);
 /** @internal */
-export const ListBudgetsOwner$outboundSchema: z.ZodNativeEnum<
-  typeof ListBudgetsOwner
-> = ListBudgetsOwner$inboundSchema;
+export const ListBudgetsDataOwner$outboundSchema: z.ZodNativeEnum<
+  typeof ListBudgetsDataOwner
+> = ListBudgetsDataOwner$inboundSchema;
 
 /** @internal */
-export const ListBudgetsPeriod$inboundSchema: z.ZodNativeEnum<
-  typeof ListBudgetsPeriod
-> = z.nativeEnum(ListBudgetsPeriod);
+export const ListBudgetsDataPeriod$inboundSchema: z.ZodNativeEnum<
+  typeof ListBudgetsDataPeriod
+> = z.nativeEnum(ListBudgetsDataPeriod);
 /** @internal */
-export const ListBudgetsPeriod$outboundSchema: z.ZodNativeEnum<
-  typeof ListBudgetsPeriod
-> = ListBudgetsPeriod$inboundSchema;
+export const ListBudgetsDataPeriod$outboundSchema: z.ZodNativeEnum<
+  typeof ListBudgetsDataPeriod
+> = ListBudgetsDataPeriod$inboundSchema;
 
 /** @internal */
-export const ListBudgetsAction$inboundSchema: z.ZodNativeEnum<
-  typeof ListBudgetsAction
-> = z.nativeEnum(ListBudgetsAction);
+export const ListBudgetsDataAction$inboundSchema: z.ZodNativeEnum<
+  typeof ListBudgetsDataAction
+> = z.nativeEnum(ListBudgetsDataAction);
 /** @internal */
-export const ListBudgetsAction$outboundSchema: z.ZodNativeEnum<
-  typeof ListBudgetsAction
-> = ListBudgetsAction$inboundSchema;
+export const ListBudgetsDataAction$outboundSchema: z.ZodNativeEnum<
+  typeof ListBudgetsDataAction
+> = ListBudgetsDataAction$inboundSchema;
 
 /** @internal */
-export const ListBudgetsThresholds$inboundSchema: z.ZodType<
-  ListBudgetsThresholds,
+export const ListBudgetsDataThresholds$inboundSchema: z.ZodType<
+  ListBudgetsDataThresholds,
   z.ZodTypeDef,
   unknown
 > = z.object({
   pct: z.number().int(),
-  action: ListBudgetsAction$inboundSchema,
+  action: ListBudgetsDataAction$inboundSchema,
 });
 /** @internal */
-export type ListBudgetsThresholds$Outbound = {
+export type ListBudgetsDataThresholds$Outbound = {
   pct: number;
   action: string;
 };
 
 /** @internal */
-export const ListBudgetsThresholds$outboundSchema: z.ZodType<
-  ListBudgetsThresholds$Outbound,
+export const ListBudgetsDataThresholds$outboundSchema: z.ZodType<
+  ListBudgetsDataThresholds$Outbound,
   z.ZodTypeDef,
-  ListBudgetsThresholds
+  ListBudgetsDataThresholds
 > = z.object({
   pct: z.number().int(),
-  action: ListBudgetsAction$outboundSchema,
+  action: ListBudgetsDataAction$outboundSchema,
 });
 
-export function listBudgetsThresholdsToJSON(
-  listBudgetsThresholds: ListBudgetsThresholds,
+export function listBudgetsDataThresholdsToJSON(
+  listBudgetsDataThresholds: ListBudgetsDataThresholds,
 ): string {
   return JSON.stringify(
-    ListBudgetsThresholds$outboundSchema.parse(listBudgetsThresholds),
+    ListBudgetsDataThresholds$outboundSchema.parse(listBudgetsDataThresholds),
   );
 }
-export function listBudgetsThresholdsFromJSON(
+export function listBudgetsDataThresholdsFromJSON(
   jsonString: string,
-): SafeParseResult<ListBudgetsThresholds, SDKValidationError> {
+): SafeParseResult<ListBudgetsDataThresholds, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ListBudgetsThresholds$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListBudgetsThresholds' from JSON`,
+    (x) => ListBudgetsDataThresholds$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListBudgetsDataThresholds' from JSON`,
   );
 }
 
 /** @internal */
-export const ListBudgetsStatus$inboundSchema: z.ZodNativeEnum<
-  typeof ListBudgetsStatus
-> = z.nativeEnum(ListBudgetsStatus);
+export const DataStatus$inboundSchema: z.ZodNativeEnum<typeof DataStatus> = z
+  .nativeEnum(DataStatus);
 /** @internal */
-export const ListBudgetsStatus$outboundSchema: z.ZodNativeEnum<
-  typeof ListBudgetsStatus
-> = ListBudgetsStatus$inboundSchema;
+export const DataStatus$outboundSchema: z.ZodNativeEnum<typeof DataStatus> =
+  DataStatus$inboundSchema;
 
 /** @internal */
-export const ListBudgetsSpend$inboundSchema: z.ZodType<
-  ListBudgetsSpend,
+export const DataSpend$inboundSchema: z.ZodType<
+  DataSpend,
   z.ZodTypeDef,
   unknown
 > = z.object({
@@ -177,14 +365,14 @@ export const ListBudgetsSpend$inboundSchema: z.ZodType<
   cost_spent: z.number(),
   limit: z.number(),
   pct: z.number().int(),
-  status: ListBudgetsStatus$inboundSchema,
+  status: DataStatus$inboundSchema,
 }).transform((v) => {
   return remap$(v, {
     "cost_spent": "costSpent",
   });
 });
 /** @internal */
-export type ListBudgetsSpend$Outbound = {
+export type DataSpend$Outbound = {
   window: string;
   cost_spent: number;
   limit: number;
@@ -193,64 +381,57 @@ export type ListBudgetsSpend$Outbound = {
 };
 
 /** @internal */
-export const ListBudgetsSpend$outboundSchema: z.ZodType<
-  ListBudgetsSpend$Outbound,
+export const DataSpend$outboundSchema: z.ZodType<
+  DataSpend$Outbound,
   z.ZodTypeDef,
-  ListBudgetsSpend
+  DataSpend
 > = z.object({
   window: z.string(),
   costSpent: z.number(),
   limit: z.number(),
   pct: z.number().int(),
-  status: ListBudgetsStatus$outboundSchema,
+  status: DataStatus$outboundSchema,
 }).transform((v) => {
   return remap$(v, {
     costSpent: "cost_spent",
   });
 });
 
-export function listBudgetsSpendToJSON(
-  listBudgetsSpend: ListBudgetsSpend,
-): string {
-  return JSON.stringify(
-    ListBudgetsSpend$outboundSchema.parse(listBudgetsSpend),
-  );
+export function dataSpendToJSON(dataSpend: DataSpend): string {
+  return JSON.stringify(DataSpend$outboundSchema.parse(dataSpend));
 }
-export function listBudgetsSpendFromJSON(
+export function dataSpendFromJSON(
   jsonString: string,
-): SafeParseResult<ListBudgetsSpend, SDKValidationError> {
+): SafeParseResult<DataSpend, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => ListBudgetsSpend$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ListBudgetsSpend' from JSON`,
+    (x) => DataSpend$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DataSpend' from JSON`,
   );
 }
 
 /** @internal */
-export const ListBudgetsData$inboundSchema: z.ZodType<
-  ListBudgetsData,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  id: z.string(),
-  scope: ListBudgetsScope$inboundSchema,
-  scope_id: z.string(),
-  scope_org_id: z.nullable(z.string()),
-  owner: ListBudgetsOwner$inboundSchema,
-  period: ListBudgetsPeriod$inboundSchema,
-  limit: z.number(),
-  thresholds: z.array(z.lazy(() => ListBudgetsThresholds$inboundSchema)),
-  alert_webhook_url: z.nullable(z.string()),
-  spend: z.lazy(() => ListBudgetsSpend$inboundSchema),
-}).transform((v) => {
-  return remap$(v, {
-    "scope_id": "scopeId",
-    "scope_org_id": "scopeOrgId",
-    "alert_webhook_url": "alertWebhookUrl",
+export const Data1$inboundSchema: z.ZodType<Data1, z.ZodTypeDef, unknown> = z
+  .object({
+    id: z.string(),
+    scope: ListBudgetsDataScope$inboundSchema,
+    scope_id: z.string(),
+    scope_org_id: z.nullable(z.string()),
+    owner: ListBudgetsDataOwner$inboundSchema,
+    period: ListBudgetsDataPeriod$inboundSchema,
+    limit: z.number(),
+    thresholds: z.array(z.lazy(() => ListBudgetsDataThresholds$inboundSchema)),
+    alert_webhook_url: z.nullable(z.string()),
+    spend: z.lazy(() => DataSpend$inboundSchema),
+  }).transform((v) => {
+    return remap$(v, {
+      "scope_id": "scopeId",
+      "scope_org_id": "scopeOrgId",
+      "alert_webhook_url": "alertWebhookUrl",
+    });
   });
-});
 /** @internal */
-export type ListBudgetsData$Outbound = {
+export type Data1$Outbound = {
   id: string;
   scope: string;
   scope_id: string;
@@ -258,27 +439,27 @@ export type ListBudgetsData$Outbound = {
   owner: string;
   period: string;
   limit: number;
-  thresholds: Array<ListBudgetsThresholds$Outbound>;
+  thresholds: Array<ListBudgetsDataThresholds$Outbound>;
   alert_webhook_url: string | null;
-  spend: ListBudgetsSpend$Outbound;
+  spend: DataSpend$Outbound;
 };
 
 /** @internal */
-export const ListBudgetsData$outboundSchema: z.ZodType<
-  ListBudgetsData$Outbound,
+export const Data1$outboundSchema: z.ZodType<
+  Data1$Outbound,
   z.ZodTypeDef,
-  ListBudgetsData
+  Data1
 > = z.object({
   id: z.string(),
-  scope: ListBudgetsScope$outboundSchema,
+  scope: ListBudgetsDataScope$outboundSchema,
   scopeId: z.string(),
   scopeOrgId: z.nullable(z.string()),
-  owner: ListBudgetsOwner$outboundSchema,
-  period: ListBudgetsPeriod$outboundSchema,
+  owner: ListBudgetsDataOwner$outboundSchema,
+  period: ListBudgetsDataPeriod$outboundSchema,
   limit: z.number(),
-  thresholds: z.array(z.lazy(() => ListBudgetsThresholds$outboundSchema)),
+  thresholds: z.array(z.lazy(() => ListBudgetsDataThresholds$outboundSchema)),
   alertWebhookUrl: z.nullable(z.string()),
-  spend: z.lazy(() => ListBudgetsSpend$outboundSchema),
+  spend: z.lazy(() => DataSpend$outboundSchema),
 }).transform((v) => {
   return remap$(v, {
     scopeId: "scope_id",
@@ -287,6 +468,41 @@ export const ListBudgetsData$outboundSchema: z.ZodType<
   });
 });
 
+export function data1ToJSON(data1: Data1): string {
+  return JSON.stringify(Data1$outboundSchema.parse(data1));
+}
+export function data1FromJSON(
+  jsonString: string,
+): SafeParseResult<Data1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Data1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Data1' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListBudgetsData$inboundSchema: z.ZodType<
+  ListBudgetsData,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => Data1$inboundSchema),
+  z.lazy(() => Data2$inboundSchema),
+]);
+/** @internal */
+export type ListBudgetsData$Outbound = Data1$Outbound | Data2$Outbound;
+
+/** @internal */
+export const ListBudgetsData$outboundSchema: z.ZodType<
+  ListBudgetsData$Outbound,
+  z.ZodTypeDef,
+  ListBudgetsData
+> = z.union([
+  z.lazy(() => Data1$outboundSchema),
+  z.lazy(() => Data2$outboundSchema),
+]);
+
 export function listBudgetsDataToJSON(
   listBudgetsData: ListBudgetsData,
 ): string {
@@ -309,12 +525,17 @@ export const ListBudgetsResponseBody$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   object: z.literal("list"),
-  data: z.array(z.lazy(() => ListBudgetsData$inboundSchema)),
+  data: z.array(
+    z.union([
+      z.lazy(() => Data1$inboundSchema),
+      z.lazy(() => Data2$inboundSchema),
+    ]),
+  ),
 });
 /** @internal */
 export type ListBudgetsResponseBody$Outbound = {
   object: "list";
-  data: Array<ListBudgetsData$Outbound>;
+  data: Array<Data1$Outbound | Data2$Outbound>;
 };
 
 /** @internal */
@@ -324,7 +545,12 @@ export const ListBudgetsResponseBody$outboundSchema: z.ZodType<
   ListBudgetsResponseBody
 > = z.object({
   object: z.literal("list"),
-  data: z.array(z.lazy(() => ListBudgetsData$outboundSchema)),
+  data: z.array(
+    z.union([
+      z.lazy(() => Data1$outboundSchema),
+      z.lazy(() => Data2$outboundSchema),
+    ]),
+  ),
 });
 
 export function listBudgetsResponseBodyToJSON(