@meetkai/mka1 0.48.31 → 0.48.33

package/src/models/operations/setorgbudget.ts

@@ -5,15 +5,249 @@
 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 * as components from "../components/index.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
+/**
+ * cluster = operator ceiling (org-admin read-only); org = self-budget
+ */
+export const Owner = {
+  Cluster: "cluster",
+  Org: "org",
+} as const;
+/**
+ * cluster = operator ceiling (org-admin read-only); org = self-budget
+ */
+export type Owner = ClosedEnum<typeof Owner>;
+
+export const Period = {
+  Daily: "daily",
+  Weekly: "weekly",
+  Monthly: "monthly",
+} as const;
+export type Period = ClosedEnum<typeof Period>;
+
+export const Action = {
+  Alert: "alert",
+  Block: "block",
+} as const;
+export type Action = ClosedEnum<typeof Action>;
+
+export type Thresholds = {
+  pct: number;
+  action: Action;
+};
+
+export type SetOrgBudgetRequestBody = {
+  /**
+   * cluster = operator ceiling (org-admin read-only); org = self-budget
+   */
+  owner?: Owner | undefined;
+  period: Period;
+  /**
+   * Spend limit in major currency units
+   */
+  limit: number;
+  thresholds: Array<Thresholds>;
+  webhookUrl?: string | null | undefined;
+  webhookSecret?: string | null | undefined;
+};
+
 export type SetOrgBudgetRequest = {
   orgId: string;
-  putBudgetBody: components.PutBudgetBody;
+  requestBody: SetOrgBudgetRequestBody;
+};
+
+export const Scope = {
+  Org: "org",
+  Apikey: "apikey",
+} as const;
+export type Scope = ClosedEnum<typeof Scope>;
+
+export const SetOrgBudgetOwner = {
+  Cluster: "cluster",
+  Org: "org",
+} as const;
+export type SetOrgBudgetOwner = ClosedEnum<typeof SetOrgBudgetOwner>;
+
+export const SetOrgBudgetPeriod = {
+  Daily: "daily",
+  Weekly: "weekly",
+  Monthly: "monthly",
+} as const;
+export type SetOrgBudgetPeriod = ClosedEnum<typeof SetOrgBudgetPeriod>;
+
+export const SetOrgBudgetAction = {
+  Alert: "alert",
+  Block: "block",
+} as const;
+export type SetOrgBudgetAction = ClosedEnum<typeof SetOrgBudgetAction>;
+
+export type SetOrgBudgetThresholds = {
+  pct: number;
+  action: SetOrgBudgetAction;
+};
+
+export const SetOrgBudgetStatus = {
+  Ok: "ok",
+  Blocked: "blocked",
+} as const;
+export type SetOrgBudgetStatus = ClosedEnum<typeof SetOrgBudgetStatus>;
+
+export type Spend = {
+  /**
+   * 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: SetOrgBudgetStatus;
+};
+
+/**
+ * OK
+ */
+export type SetOrgBudgetResponseBody = {
+  id: string;
+  scope: Scope;
+  scopeId: string;
+  owner: SetOrgBudgetOwner;
+  period: SetOrgBudgetPeriod;
+  limit: number;
+  thresholds: Array<SetOrgBudgetThresholds>;
+  alertWebhookUrl: string | null;
+  spend: Spend;
 };
 
+/** @internal */
+export const Owner$inboundSchema: z.ZodNativeEnum<typeof Owner> = z.nativeEnum(
+  Owner,
+);
+/** @internal */
+export const Owner$outboundSchema: z.ZodNativeEnum<typeof Owner> =
+  Owner$inboundSchema;
+
+/** @internal */
+export const Period$inboundSchema: z.ZodNativeEnum<typeof Period> = z
+  .nativeEnum(Period);
+/** @internal */
+export const Period$outboundSchema: z.ZodNativeEnum<typeof Period> =
+  Period$inboundSchema;
+
+/** @internal */
+export const Action$inboundSchema: z.ZodNativeEnum<typeof Action> = z
+  .nativeEnum(Action);
+/** @internal */
+export const Action$outboundSchema: z.ZodNativeEnum<typeof Action> =
+  Action$inboundSchema;
+
+/** @internal */
+export const Thresholds$inboundSchema: z.ZodType<
+  Thresholds,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  pct: z.number().int(),
+  action: Action$inboundSchema,
+});
+/** @internal */
+export type Thresholds$Outbound = {
+  pct: number;
+  action: string;
+};
+
+/** @internal */
+export const Thresholds$outboundSchema: z.ZodType<
+  Thresholds$Outbound,
+  z.ZodTypeDef,
+  Thresholds
+> = z.object({
+  pct: z.number().int(),
+  action: Action$outboundSchema,
+});
+
+export function thresholdsToJSON(thresholds: Thresholds): string {
+  return JSON.stringify(Thresholds$outboundSchema.parse(thresholds));
+}
+export function thresholdsFromJSON(
+  jsonString: string,
+): SafeParseResult<Thresholds, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Thresholds$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Thresholds' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetOrgBudgetRequestBody$inboundSchema: z.ZodType<
+  SetOrgBudgetRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  owner: Owner$inboundSchema.default("org"),
+  period: Period$inboundSchema,
+  limit: z.number(),
+  thresholds: z.array(z.lazy(() => Thresholds$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 SetOrgBudgetRequestBody$Outbound = {
+  owner: string;
+  period: string;
+  limit: number;
+  thresholds: Array<Thresholds$Outbound>;
+  webhook_url?: string | null | undefined;
+  webhook_secret?: string | null | undefined;
+};
+
+/** @internal */
+export const SetOrgBudgetRequestBody$outboundSchema: z.ZodType<
+  SetOrgBudgetRequestBody$Outbound,
+  z.ZodTypeDef,
+  SetOrgBudgetRequestBody
+> = z.object({
+  owner: Owner$outboundSchema.default("org"),
+  period: Period$outboundSchema,
+  limit: z.number(),
+  thresholds: z.array(z.lazy(() => Thresholds$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 setOrgBudgetRequestBodyToJSON(
+  setOrgBudgetRequestBody: SetOrgBudgetRequestBody,
+): string {
+  return JSON.stringify(
+    SetOrgBudgetRequestBody$outboundSchema.parse(setOrgBudgetRequestBody),
+  );
+}
+export function setOrgBudgetRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<SetOrgBudgetRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SetOrgBudgetRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetOrgBudgetRequestBody' from JSON`,
+  );
+}
+
 /** @internal */
 export const SetOrgBudgetRequest$inboundSchema: z.ZodType<
   SetOrgBudgetRequest,
@@ -21,16 +255,16 @@ export const SetOrgBudgetRequest$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   orgId: z.string(),
-  PutBudgetBody: components.PutBudgetBody$inboundSchema,
+  RequestBody: z.lazy(() => SetOrgBudgetRequestBody$inboundSchema),
 }).transform((v) => {
   return remap$(v, {
-    "PutBudgetBody": "putBudgetBody",
+    "RequestBody": "requestBody",
   });
 });
 /** @internal */
 export type SetOrgBudgetRequest$Outbound = {
   orgId: string;
-  PutBudgetBody: components.PutBudgetBody$Outbound;
+  RequestBody: SetOrgBudgetRequestBody$Outbound;
 };
 
 /** @internal */
@@ -40,10 +274,10 @@ export const SetOrgBudgetRequest$outboundSchema: z.ZodType<
   SetOrgBudgetRequest
 > = z.object({
   orgId: z.string(),
-  putBudgetBody: components.PutBudgetBody$outboundSchema,
+  requestBody: z.lazy(() => SetOrgBudgetRequestBody$outboundSchema),
 }).transform((v) => {
   return remap$(v, {
-    putBudgetBody: "PutBudgetBody",
+    requestBody: "RequestBody",
   });
 });
 
@@ -63,3 +297,214 @@ export function setOrgBudgetRequestFromJSON(
     `Failed to parse 'SetOrgBudgetRequest' from JSON`,
   );
 }
+
+/** @internal */
+export const Scope$inboundSchema: z.ZodNativeEnum<typeof Scope> = z.nativeEnum(
+  Scope,
+);
+/** @internal */
+export const Scope$outboundSchema: z.ZodNativeEnum<typeof Scope> =
+  Scope$inboundSchema;
+
+/** @internal */
+export const SetOrgBudgetOwner$inboundSchema: z.ZodNativeEnum<
+  typeof SetOrgBudgetOwner
+> = z.nativeEnum(SetOrgBudgetOwner);
+/** @internal */
+export const SetOrgBudgetOwner$outboundSchema: z.ZodNativeEnum<
+  typeof SetOrgBudgetOwner
+> = SetOrgBudgetOwner$inboundSchema;
+
+/** @internal */
+export const SetOrgBudgetPeriod$inboundSchema: z.ZodNativeEnum<
+  typeof SetOrgBudgetPeriod
+> = z.nativeEnum(SetOrgBudgetPeriod);
+/** @internal */
+export const SetOrgBudgetPeriod$outboundSchema: z.ZodNativeEnum<
+  typeof SetOrgBudgetPeriod
+> = SetOrgBudgetPeriod$inboundSchema;
+
+/** @internal */
+export const SetOrgBudgetAction$inboundSchema: z.ZodNativeEnum<
+  typeof SetOrgBudgetAction
+> = z.nativeEnum(SetOrgBudgetAction);
+/** @internal */
+export const SetOrgBudgetAction$outboundSchema: z.ZodNativeEnum<
+  typeof SetOrgBudgetAction
+> = SetOrgBudgetAction$inboundSchema;
+
+/** @internal */
+export const SetOrgBudgetThresholds$inboundSchema: z.ZodType<
+  SetOrgBudgetThresholds,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  pct: z.number().int(),
+  action: SetOrgBudgetAction$inboundSchema,
+});
+/** @internal */
+export type SetOrgBudgetThresholds$Outbound = {
+  pct: number;
+  action: string;
+};
+
+/** @internal */
+export const SetOrgBudgetThresholds$outboundSchema: z.ZodType<
+  SetOrgBudgetThresholds$Outbound,
+  z.ZodTypeDef,
+  SetOrgBudgetThresholds
+> = z.object({
+  pct: z.number().int(),
+  action: SetOrgBudgetAction$outboundSchema,
+});
+
+export function setOrgBudgetThresholdsToJSON(
+  setOrgBudgetThresholds: SetOrgBudgetThresholds,
+): string {
+  return JSON.stringify(
+    SetOrgBudgetThresholds$outboundSchema.parse(setOrgBudgetThresholds),
+  );
+}
+export function setOrgBudgetThresholdsFromJSON(
+  jsonString: string,
+): SafeParseResult<SetOrgBudgetThresholds, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SetOrgBudgetThresholds$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetOrgBudgetThresholds' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetOrgBudgetStatus$inboundSchema: z.ZodNativeEnum<
+  typeof SetOrgBudgetStatus
+> = z.nativeEnum(SetOrgBudgetStatus);
+/** @internal */
+export const SetOrgBudgetStatus$outboundSchema: z.ZodNativeEnum<
+  typeof SetOrgBudgetStatus
+> = SetOrgBudgetStatus$inboundSchema;
+
+/** @internal */
+export const Spend$inboundSchema: z.ZodType<Spend, z.ZodTypeDef, unknown> = z
+  .object({
+    window: z.string(),
+    cost_spent: z.number(),
+    limit: z.number(),
+    pct: z.number().int(),
+    status: SetOrgBudgetStatus$inboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      "cost_spent": "costSpent",
+    });
+  });
+/** @internal */
+export type Spend$Outbound = {
+  window: string;
+  cost_spent: number;
+  limit: number;
+  pct: number;
+  status: string;
+};
+
+/** @internal */
+export const Spend$outboundSchema: z.ZodType<
+  Spend$Outbound,
+  z.ZodTypeDef,
+  Spend
+> = z.object({
+  window: z.string(),
+  costSpent: z.number(),
+  limit: z.number(),
+  pct: z.number().int(),
+  status: SetOrgBudgetStatus$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    costSpent: "cost_spent",
+  });
+});
+
+export function spendToJSON(spend: Spend): string {
+  return JSON.stringify(Spend$outboundSchema.parse(spend));
+}
+export function spendFromJSON(
+  jsonString: string,
+): SafeParseResult<Spend, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Spend$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Spend' from JSON`,
+  );
+}
+
+/** @internal */
+export const SetOrgBudgetResponseBody$inboundSchema: z.ZodType<
+  SetOrgBudgetResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  scope: Scope$inboundSchema,
+  scope_id: z.string(),
+  owner: SetOrgBudgetOwner$inboundSchema,
+  period: SetOrgBudgetPeriod$inboundSchema,
+  limit: z.number(),
+  thresholds: z.array(z.lazy(() => SetOrgBudgetThresholds$inboundSchema)),
+  alert_webhook_url: z.nullable(z.string()),
+  spend: z.lazy(() => Spend$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "scope_id": "scopeId",
+    "alert_webhook_url": "alertWebhookUrl",
+  });
+});
+/** @internal */
+export type SetOrgBudgetResponseBody$Outbound = {
+  id: string;
+  scope: string;
+  scope_id: string;
+  owner: string;
+  period: string;
+  limit: number;
+  thresholds: Array<SetOrgBudgetThresholds$Outbound>;
+  alert_webhook_url: string | null;
+  spend: Spend$Outbound;
+};
+
+/** @internal */
+export const SetOrgBudgetResponseBody$outboundSchema: z.ZodType<
+  SetOrgBudgetResponseBody$Outbound,
+  z.ZodTypeDef,
+  SetOrgBudgetResponseBody
+> = z.object({
+  id: z.string(),
+  scope: Scope$outboundSchema,
+  scopeId: z.string(),
+  owner: SetOrgBudgetOwner$outboundSchema,
+  period: SetOrgBudgetPeriod$outboundSchema,
+  limit: z.number(),
+  thresholds: z.array(z.lazy(() => SetOrgBudgetThresholds$outboundSchema)),
+  alertWebhookUrl: z.nullable(z.string()),
+  spend: z.lazy(() => Spend$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    scopeId: "scope_id",
+    alertWebhookUrl: "alert_webhook_url",
+  });
+});
+
+export function setOrgBudgetResponseBodyToJSON(
+  setOrgBudgetResponseBody: SetOrgBudgetResponseBody,
+): string {
+  return JSON.stringify(
+    SetOrgBudgetResponseBody$outboundSchema.parse(setOrgBudgetResponseBody),
+  );
+}
+export function setOrgBudgetResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<SetOrgBudgetResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SetOrgBudgetResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SetOrgBudgetResponseBody' from JSON`,
+  );
+}

package/src/react-query/budgetsApiKeyEvents.core.ts

@@ -0,0 +1,71 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  QueryClient,
+  QueryFunctionContext,
+  QueryKey,
+} from "@tanstack/react-query";
+import { SDKCore } from "../core.js";
+import { budgetsApiKeyEvents } from "../funcs/budgetsApiKeyEvents.js";
+import { combineSignals } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+export type BudgetsApiKeyEventsQueryData =
+  operations.ListApiKeyBudgetEventsResponseBody;
+
+export function prefetchBudgetsApiKeyEvents(
+  queryClient: QueryClient,
+  client$: SDKCore,
+  request: operations.ListApiKeyBudgetEventsRequest,
+  options?: RequestOptions,
+): Promise<void> {
+  return queryClient.prefetchQuery({
+    ...buildBudgetsApiKeyEventsQuery(
+      client$,
+      request,
+      options,
+    ),
+  });
+}
+
+export function buildBudgetsApiKeyEventsQuery(
+  client$: SDKCore,
+  request: operations.ListApiKeyBudgetEventsRequest,
+  options?: RequestOptions,
+): {
+  queryKey: QueryKey;
+  queryFn: (
+    context: QueryFunctionContext,
+  ) => Promise<BudgetsApiKeyEventsQueryData>;
+} {
+  return {
+    queryKey: queryKeyBudgetsApiKeyEvents(request.apiKeyId),
+    queryFn: async function budgetsApiKeyEventsQueryFn(
+      ctx,
+    ): Promise<BudgetsApiKeyEventsQueryData> {
+      const sig = combineSignals(
+        ctx.signal,
+        options?.signal,
+        options?.fetchOptions?.signal,
+      );
+      const mergedOptions = {
+        ...options?.fetchOptions,
+        ...options,
+        signal: sig,
+      };
+
+      return unwrapAsync(budgetsApiKeyEvents(
+        client$,
+        request,
+        mergedOptions,
+      ));
+    },
+  };
+}
+
+export function queryKeyBudgetsApiKeyEvents(apiKeyId: string): QueryKey {
+  return ["@meetkai/mka1", "budgets", "apiKeyEvents", apiKeyId];
+}

package/src/react-query/budgetsApiKeyEvents.ts

@@ -0,0 +1,133 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  InvalidateQueryFilters,
+  QueryClient,
+  useQuery,
+  UseQueryResult,
+  useSuspenseQuery,
+  UseSuspenseQueryResult,
+} from "@tanstack/react-query";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKError } from "../models/errors/sdkerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { useSDKContext } from "./_context.js";
+import {
+  QueryHookOptions,
+  SuspenseQueryHookOptions,
+  TupleToPrefixes,
+} from "./_types.js";
+import {
+  BudgetsApiKeyEventsQueryData,
+  buildBudgetsApiKeyEventsQuery,
+  prefetchBudgetsApiKeyEvents,
+  queryKeyBudgetsApiKeyEvents,
+} from "./budgetsApiKeyEvents.core.js";
+export {
+  type BudgetsApiKeyEventsQueryData,
+  buildBudgetsApiKeyEventsQuery,
+  prefetchBudgetsApiKeyEvents,
+  queryKeyBudgetsApiKeyEvents,
+};
+
+export type BudgetsApiKeyEventsQueryError =
+  | SDKError
+  | ResponseValidationError
+  | ConnectionError
+  | RequestAbortedError
+  | RequestTimeoutError
+  | InvalidRequestError
+  | UnexpectedClientError
+  | SDKValidationError;
+
+/**
+ * List apikey budget events
+ *
+ * @remarks
+ * Returns recent threshold-alert and block events for the scope's budgets.
+ */
+export function useBudgetsApiKeyEvents(
+  request: operations.ListApiKeyBudgetEventsRequest,
+  options?: QueryHookOptions<
+    BudgetsApiKeyEventsQueryData,
+    BudgetsApiKeyEventsQueryError
+  >,
+): UseQueryResult<BudgetsApiKeyEventsQueryData, BudgetsApiKeyEventsQueryError> {
+  const client = useSDKContext();
+  return useQuery({
+    ...buildBudgetsApiKeyEventsQuery(
+      client,
+      request,
+      options,
+    ),
+    ...options,
+  });
+}
+
+/**
+ * List apikey budget events
+ *
+ * @remarks
+ * Returns recent threshold-alert and block events for the scope's budgets.
+ */
+export function useBudgetsApiKeyEventsSuspense(
+  request: operations.ListApiKeyBudgetEventsRequest,
+  options?: SuspenseQueryHookOptions<
+    BudgetsApiKeyEventsQueryData,
+    BudgetsApiKeyEventsQueryError
+  >,
+): UseSuspenseQueryResult<
+  BudgetsApiKeyEventsQueryData,
+  BudgetsApiKeyEventsQueryError
+> {
+  const client = useSDKContext();
+  return useSuspenseQuery({
+    ...buildBudgetsApiKeyEventsQuery(
+      client,
+      request,
+      options,
+    ),
+    ...options,
+  });
+}
+
+export function setBudgetsApiKeyEventsData(
+  client: QueryClient,
+  queryKeyBase: [apiKeyId: string],
+  data: BudgetsApiKeyEventsQueryData,
+): BudgetsApiKeyEventsQueryData | undefined {
+  const key = queryKeyBudgetsApiKeyEvents(...queryKeyBase);
+
+  return client.setQueryData<BudgetsApiKeyEventsQueryData>(key, data);
+}
+
+export function invalidateBudgetsApiKeyEvents(
+  client: QueryClient,
+  queryKeyBase: TupleToPrefixes<[apiKeyId: string]>,
+  filters?: Omit<InvalidateQueryFilters, "queryKey" | "predicate" | "exact">,
+): Promise<void> {
+  return client.invalidateQueries({
+    ...filters,
+    queryKey: ["@meetkai/mka1", "budgets", "apiKeyEvents", ...queryKeyBase],
+  });
+}
+
+export function invalidateAllBudgetsApiKeyEvents(
+  client: QueryClient,
+  filters?: Omit<InvalidateQueryFilters, "queryKey" | "predicate" | "exact">,
+): Promise<void> {
+  return client.invalidateQueries({
+    ...filters,
+    queryKey: ["@meetkai/mka1", "budgets", "apiKeyEvents"],
+  });
+}