/*
 * 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";

/**
 * cluster = operator ceiling (org-admin read-only); org = self-budget
 */
export const SetExternalUserBudgetOwner = {
  Cluster: "cluster",
  Org: "org",
} as const;
/**
 * cluster = operator ceiling (org-admin read-only); org = self-budget
 */
export type SetExternalUserBudgetOwner = ClosedEnum<
  typeof SetExternalUserBudgetOwner
>;

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

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

export type SetExternalUserBudgetThresholds = {
  pct: number;
  action: SetExternalUserBudgetAction;
};

export type SetExternalUserBudgetRequestBody = {
  /**
   * cluster = operator ceiling (org-admin read-only); org = self-budget
   */
  owner?: SetExternalUserBudgetOwner | undefined;
  period: SetExternalUserBudgetPeriod;
  /**
   * Spend limit in major currency units
   */
  limit: number;
  thresholds: Array<SetExternalUserBudgetThresholds>;
  webhookUrl?: string | null | undefined;
  webhookSecret?: string | null | undefined;
};

export type SetExternalUserBudgetRequest = {
  id: string;
  orgId?: string | undefined;
  requestBody: SetExternalUserBudgetRequestBody;
};

export const SetExternalUserBudgetScope = {
  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 SetExternalUserBudgetScope = ClosedEnum<
  typeof SetExternalUserBudgetScope
>;

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

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

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

export type SetExternalUserBudgetBudgetsThresholds = {
  pct: number;
  action: SetExternalUserBudgetBudgetsAction;
};

export const SetExternalUserBudgetStatus = {
  Ok: "ok",
  Blocked: "blocked",
} as const;
export type SetExternalUserBudgetStatus = ClosedEnum<
  typeof SetExternalUserBudgetStatus
>;

export type SetExternalUserBudgetSpend = {
  /**
   * 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: SetExternalUserBudgetStatus;
};

/**
 * OK
 */
export type SetExternalUserBudgetResponseBody = {
  id: string;
  scope: SetExternalUserBudgetScope;
  scopeId: string;
  scopeOrgId: string | null;
  owner: SetExternalUserBudgetBudgetsOwner;
  period: SetExternalUserBudgetBudgetsPeriod;
  limit: number;
  thresholds: Array<SetExternalUserBudgetBudgetsThresholds>;
  alertWebhookUrl: string | null;
  spend: SetExternalUserBudgetSpend;
};

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

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

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

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

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

export function setExternalUserBudgetThresholdsToJSON(
  setExternalUserBudgetThresholds: SetExternalUserBudgetThresholds,
): string {
  return JSON.stringify(
    SetExternalUserBudgetThresholds$outboundSchema.parse(
      setExternalUserBudgetThresholds,
    ),
  );
}
export function setExternalUserBudgetThresholdsFromJSON(
  jsonString: string,
): SafeParseResult<SetExternalUserBudgetThresholds, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => SetExternalUserBudgetThresholds$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'SetExternalUserBudgetThresholds' from JSON`,
  );
}

/** @internal */
export const SetExternalUserBudgetRequestBody$inboundSchema: z.ZodType<
  SetExternalUserBudgetRequestBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  owner: SetExternalUserBudgetOwner$inboundSchema.default("org"),
  period: SetExternalUserBudgetPeriod$inboundSchema,
  limit: z.number(),
  thresholds: z.array(
    z.lazy(() => SetExternalUserBudgetThresholds$inboundSchema),
  ),
  webhook_url: z.nullable(z.string()).optional(),
  webhook_secret: z.nullable(z.string()).optional(),
}).transform((v) => {
  return remap$(v, {
    "webhook_url": "webhookUrl",
    "webhook_secret": "webhookSecret",
  });
});
/** @internal */
export type SetExternalUserBudgetRequestBody$Outbound = {
  owner: string;
  period: string;
  limit: number;
  thresholds: Array<SetExternalUserBudgetThresholds$Outbound>;
  webhook_url?: string | null | undefined;
  webhook_secret?: string | null | undefined;
};

/** @internal */
export const SetExternalUserBudgetRequestBody$outboundSchema: z.ZodType<
  SetExternalUserBudgetRequestBody$Outbound,
  z.ZodTypeDef,
  SetExternalUserBudgetRequestBody
> = z.object({
  owner: SetExternalUserBudgetOwner$outboundSchema.default("org"),
  period: SetExternalUserBudgetPeriod$outboundSchema,
  limit: z.number(),
  thresholds: z.array(
    z.lazy(() => SetExternalUserBudgetThresholds$outboundSchema),
  ),
  webhookUrl: z.nullable(z.string()).optional(),
  webhookSecret: z.nullable(z.string()).optional(),
}).transform((v) => {
  return remap$(v, {
    webhookUrl: "webhook_url",
    webhookSecret: "webhook_secret",
  });
});

export function setExternalUserBudgetRequestBodyToJSON(
  setExternalUserBudgetRequestBody: SetExternalUserBudgetRequestBody,
): string {
  return JSON.stringify(
    SetExternalUserBudgetRequestBody$outboundSchema.parse(
      setExternalUserBudgetRequestBody,
    ),
  );
}
export function setExternalUserBudgetRequestBodyFromJSON(
  jsonString: string,
): SafeParseResult<SetExternalUserBudgetRequestBody, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => SetExternalUserBudgetRequestBody$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'SetExternalUserBudgetRequestBody' from JSON`,
  );
}

/** @internal */
export const SetExternalUserBudgetRequest$inboundSchema: z.ZodType<
  SetExternalUserBudgetRequest,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: z.string(),
  org_id: z.string().optional(),
  RequestBody: z.lazy(() => SetExternalUserBudgetRequestBody$inboundSchema),
}).transform((v) => {
  return remap$(v, {
    "org_id": "orgId",
    "RequestBody": "requestBody",
  });
});
/** @internal */
export type SetExternalUserBudgetRequest$Outbound = {
  id: string;
  org_id?: string | undefined;
  RequestBody: SetExternalUserBudgetRequestBody$Outbound;
};

/** @internal */
export const SetExternalUserBudgetRequest$outboundSchema: z.ZodType<
  SetExternalUserBudgetRequest$Outbound,
  z.ZodTypeDef,
  SetExternalUserBudgetRequest
> = z.object({
  id: z.string(),
  orgId: z.string().optional(),
  requestBody: z.lazy(() => SetExternalUserBudgetRequestBody$outboundSchema),
}).transform((v) => {
  return remap$(v, {
    orgId: "org_id",
    requestBody: "RequestBody",
  });
});

export function setExternalUserBudgetRequestToJSON(
  setExternalUserBudgetRequest: SetExternalUserBudgetRequest,
): string {
  return JSON.stringify(
    SetExternalUserBudgetRequest$outboundSchema.parse(
      setExternalUserBudgetRequest,
    ),
  );
}
export function setExternalUserBudgetRequestFromJSON(
  jsonString: string,
): SafeParseResult<SetExternalUserBudgetRequest, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => SetExternalUserBudgetRequest$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'SetExternalUserBudgetRequest' from JSON`,
  );
}

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

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

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

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

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

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

export function setExternalUserBudgetBudgetsThresholdsToJSON(
  setExternalUserBudgetBudgetsThresholds:
    SetExternalUserBudgetBudgetsThresholds,
): string {
  return JSON.stringify(
    SetExternalUserBudgetBudgetsThresholds$outboundSchema.parse(
      setExternalUserBudgetBudgetsThresholds,
    ),
  );
}
export function setExternalUserBudgetBudgetsThresholdsFromJSON(
  jsonString: string,
): SafeParseResult<SetExternalUserBudgetBudgetsThresholds, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      SetExternalUserBudgetBudgetsThresholds$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'SetExternalUserBudgetBudgetsThresholds' from JSON`,
  );
}

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

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

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

export function setExternalUserBudgetSpendToJSON(
  setExternalUserBudgetSpend: SetExternalUserBudgetSpend,
): string {
  return JSON.stringify(
    SetExternalUserBudgetSpend$outboundSchema.parse(setExternalUserBudgetSpend),
  );
}
export function setExternalUserBudgetSpendFromJSON(
  jsonString: string,
): SafeParseResult<SetExternalUserBudgetSpend, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => SetExternalUserBudgetSpend$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'SetExternalUserBudgetSpend' from JSON`,
  );
}

/** @internal */
export const SetExternalUserBudgetResponseBody$inboundSchema: z.ZodType<
  SetExternalUserBudgetResponseBody,
  z.ZodTypeDef,
  unknown
> = z.object({
  id: z.string(),
  scope: SetExternalUserBudgetScope$inboundSchema,
  scope_id: z.string(),
  scope_org_id: z.nullable(z.string()),
  owner: SetExternalUserBudgetBudgetsOwner$inboundSchema,
  period: SetExternalUserBudgetBudgetsPeriod$inboundSchema,
  limit: z.number(),
  thresholds: z.array(
    z.lazy(() => SetExternalUserBudgetBudgetsThresholds$inboundSchema),
  ),
  alert_webhook_url: z.nullable(z.string()),
  spend: z.lazy(() => SetExternalUserBudgetSpend$inboundSchema),
}).transform((v) => {
  return remap$(v, {
    "scope_id": "scopeId",
    "scope_org_id": "scopeOrgId",
    "alert_webhook_url": "alertWebhookUrl",
  });
});
/** @internal */
export type SetExternalUserBudgetResponseBody$Outbound = {
  id: string;
  scope: string;
  scope_id: string;
  scope_org_id: string | null;
  owner: string;
  period: string;
  limit: number;
  thresholds: Array<SetExternalUserBudgetBudgetsThresholds$Outbound>;
  alert_webhook_url: string | null;
  spend: SetExternalUserBudgetSpend$Outbound;
};

/** @internal */
export const SetExternalUserBudgetResponseBody$outboundSchema: z.ZodType<
  SetExternalUserBudgetResponseBody$Outbound,
  z.ZodTypeDef,
  SetExternalUserBudgetResponseBody
> = z.object({
  id: z.string(),
  scope: SetExternalUserBudgetScope$outboundSchema,
  scopeId: z.string(),
  scopeOrgId: z.nullable(z.string()),
  owner: SetExternalUserBudgetBudgetsOwner$outboundSchema,
  period: SetExternalUserBudgetBudgetsPeriod$outboundSchema,
  limit: z.number(),
  thresholds: z.array(
    z.lazy(() => SetExternalUserBudgetBudgetsThresholds$outboundSchema),
  ),
  alertWebhookUrl: z.nullable(z.string()),
  spend: z.lazy(() => SetExternalUserBudgetSpend$outboundSchema),
}).transform((v) => {
  return remap$(v, {
    scopeId: "scope_id",
    scopeOrgId: "scope_org_id",
    alertWebhookUrl: "alert_webhook_url",
  });
});

export function setExternalUserBudgetResponseBodyToJSON(
  setExternalUserBudgetResponseBody: SetExternalUserBudgetResponseBody,
): string {
  return JSON.stringify(
    SetExternalUserBudgetResponseBody$outboundSchema.parse(
      setExternalUserBudgetResponseBody,
    ),
  );
}
export function setExternalUserBudgetResponseBodyFromJSON(
  jsonString: string,
): SafeParseResult<SetExternalUserBudgetResponseBody, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => SetExternalUserBudgetResponseBody$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'SetExternalUserBudgetResponseBody' from JSON`,
  );
}