/*
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 */

import * as z from "zod/v3";
import { remap as remap$ } from "../../lib/primitives.js";
import { safeParse } from "../../lib/schemas.js";
import { ClosedEnum } from "../../types/enums.js";
import { Result as SafeParseResult } from "../../types/fp.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";

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 DataScope = ClosedEnum<typeof DataScope>;

export const DataOwner = {
  Cluster: "cluster",
  Org: "org",
} as const;
export type DataOwner = ClosedEnum<typeof DataOwner>;

export const DataPeriod = {
  Daily: "daily",
  Weekly: "weekly",
  Monthly: "monthly",
} as const;
export type DataPeriod = ClosedEnum<typeof DataPeriod>;

export const DataAction = {
  Alert: "alert",
  Block: "block",
} as const;
export type DataAction = ClosedEnum<typeof DataAction>;

export type DataThresholds = {
  pct: number;
  action: DataAction;
};

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 DataStatus = ClosedEnum<typeof DataStatus>;

export type DataSpend = {
  /**
   * Current period bucket, e.g. 2026-07 / 2026-W28 / 2026-07-07
   */
  window: string;
  /**
   * Live spend this window, major currency units
   */
  costSpent: number;
  limit: number;
  pct: number;
  status: DataStatus;
};

export type Data1 = {
  id: string;
  scope: ListBudgetsDataScope;
  scopeId: string;
  scopeOrgId: string | null;
  owner: ListBudgetsDataOwner;
  period: ListBudgetsDataPeriod;
  limit: number;
  thresholds: Array<ListBudgetsDataThresholds>;
  alertWebhookUrl: string | null;
  spend: DataSpend;
};

export type ListBudgetsData = Data1 | Data2;

/**
 * OK
 */
export type ListBudgetsResponseBody = {
  object: "list";
  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 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 ListBudgetsDataScope$outboundSchema: z.ZodNativeEnum<
  typeof ListBudgetsDataScope
> = ListBudgetsDataScope$inboundSchema;

/** @internal */
export const ListBudgetsDataOwner$inboundSchema: z.ZodNativeEnum<
  typeof ListBudgetsDataOwner
> = z.nativeEnum(ListBudgetsDataOwner);
/** @internal */
export const ListBudgetsDataOwner$outboundSchema: z.ZodNativeEnum<
  typeof ListBudgetsDataOwner
> = ListBudgetsDataOwner$inboundSchema;

/** @internal */
export const ListBudgetsDataPeriod$inboundSchema: z.ZodNativeEnum<
  typeof ListBudgetsDataPeriod
> = z.nativeEnum(ListBudgetsDataPeriod);
/** @internal */
export const ListBudgetsDataPeriod$outboundSchema: z.ZodNativeEnum<
  typeof ListBudgetsDataPeriod
> = ListBudgetsDataPeriod$inboundSchema;

/** @internal */
export const ListBudgetsDataAction$inboundSchema: z.ZodNativeEnum<
  typeof ListBudgetsDataAction
> = z.nativeEnum(ListBudgetsDataAction);
/** @internal */
export const ListBudgetsDataAction$outboundSchema: z.ZodNativeEnum<
  typeof ListBudgetsDataAction
> = ListBudgetsDataAction$inboundSchema;

/** @internal */
export const ListBudgetsDataThresholds$inboundSchema: z.ZodType<
  ListBudgetsDataThresholds,
  z.ZodTypeDef,
  unknown
> = z.object({
  pct: z.number().int(),
  action: ListBudgetsDataAction$inboundSchema,
});
/** @internal */
export type ListBudgetsDataThresholds$Outbound = {
  pct: number;
  action: string;
};

/** @internal */
export const ListBudgetsDataThresholds$outboundSchema: z.ZodType<
  ListBudgetsDataThresholds$Outbound,
  z.ZodTypeDef,
  ListBudgetsDataThresholds
> = z.object({
  pct: z.number().int(),
  action: ListBudgetsDataAction$outboundSchema,
});

export function listBudgetsDataThresholdsToJSON(
  listBudgetsDataThresholds: ListBudgetsDataThresholds,
): string {
  return JSON.stringify(
    ListBudgetsDataThresholds$outboundSchema.parse(listBudgetsDataThresholds),
  );
}
export function listBudgetsDataThresholdsFromJSON(
  jsonString: string,
): SafeParseResult<ListBudgetsDataThresholds, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListBudgetsDataThresholds$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListBudgetsDataThresholds' from JSON`,
  );
}

/** @internal */
export const DataStatus$inboundSchema: z.ZodNativeEnum<typeof DataStatus> = z
  .nativeEnum(DataStatus);
/** @internal */
export const DataStatus$outboundSchema: z.ZodNativeEnum<typeof DataStatus> =
  DataStatus$inboundSchema;

/** @internal */
export const DataSpend$inboundSchema: z.ZodType<
  DataSpend,
  z.ZodTypeDef,
  unknown
> = z.object({
  window: z.string(),
  cost_spent: z.number(),
  limit: z.number(),
  pct: z.number().int(),
  status: DataStatus$inboundSchema,
}).transform((v) => {
  return remap$(v, {
    "cost_spent": "costSpent",
  });
});
/** @internal */
export type DataSpend$Outbound = {
  window: string;
  cost_spent: number;
  limit: number;
  pct: number;
  status: string;
};

/** @internal */
export const DataSpend$outboundSchema: z.ZodType<
  DataSpend$Outbound,
  z.ZodTypeDef,
  DataSpend
> = z.object({
  window: z.string(),
  costSpent: z.number(),
  limit: z.number(),
  pct: z.number().int(),
  status: DataStatus$outboundSchema,
}).transform((v) => {
  return remap$(v, {
    costSpent: "cost_spent",
  });
});

export function dataSpendToJSON(dataSpend: DataSpend): string {
  return JSON.stringify(DataSpend$outboundSchema.parse(dataSpend));
}
export function dataSpendFromJSON(
  jsonString: string,
): SafeParseResult<DataSpend, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => DataSpend$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'DataSpend' from JSON`,
  );
}

/** @internal */
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 Data1$Outbound = {
  id: string;
  scope: string;
  scope_id: string;
  scope_org_id: string | null;
  owner: string;
  period: string;
  limit: number;
  thresholds: Array<ListBudgetsDataThresholds$Outbound>;
  alert_webhook_url: string | null;
  spend: DataSpend$Outbound;
};

/** @internal */
export const Data1$outboundSchema: z.ZodType<
  Data1$Outbound,
  z.ZodTypeDef,
  Data1
> = z.object({
  id: z.string(),
  scope: ListBudgetsDataScope$outboundSchema,
  scopeId: z.string(),
  scopeOrgId: z.nullable(z.string()),
  owner: ListBudgetsDataOwner$outboundSchema,
  period: ListBudgetsDataPeriod$outboundSchema,
  limit: z.number(),
  thresholds: z.array(z.lazy(() => ListBudgetsDataThresholds$outboundSchema)),
  alertWebhookUrl: z.nullable(z.string()),
  spend: z.lazy(() => DataSpend$outboundSchema),
}).transform((v) => {
  return remap$(v, {
    scopeId: "scope_id",
    scopeOrgId: "scope_org_id",
    alertWebhookUrl: "alert_webhook_url",
  });
});

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 {
  return JSON.stringify(ListBudgetsData$outboundSchema.parse(listBudgetsData));
}
export function listBudgetsDataFromJSON(
  jsonString: string,
): SafeParseResult<ListBudgetsData, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListBudgetsData$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListBudgetsData' from JSON`,
  );
}

/** @internal */
export const ListBudgetsResponseBody$inboundSchema: z.ZodType<
  ListBudgetsResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  object: z.literal("list"),
  data: z.array(
    z.union([
      z.lazy(() => Data1$inboundSchema),
      z.lazy(() => Data2$inboundSchema),
    ]),
  ),
});
/** @internal */
export type ListBudgetsResponseBody$Outbound = {
  object: "list";
  data: Array<Data1$Outbound | Data2$Outbound>;
};

/** @internal */
export const ListBudgetsResponseBody$outboundSchema: z.ZodType<
  ListBudgetsResponseBody$Outbound,
  z.ZodTypeDef,
  ListBudgetsResponseBody
> = z.object({
  object: z.literal("list"),
  data: z.array(
    z.union([
      z.lazy(() => Data1$outboundSchema),
      z.lazy(() => Data2$outboundSchema),
    ]),
  ),
});

export function listBudgetsResponseBodyToJSON(
  listBudgetsResponseBody: ListBudgetsResponseBody,
): string {
  return JSON.stringify(
    ListBudgetsResponseBody$outboundSchema.parse(listBudgetsResponseBody),
  );
}
export function listBudgetsResponseBodyFromJSON(
  jsonString: string,
): SafeParseResult<ListBudgetsResponseBody, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ListBudgetsResponseBody$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ListBudgetsResponseBody' from JSON`,
  );
}