@meetkai/mka1 0.55.4 → 0.55.5

package/src/models/operations/createchatcompletionstream.ts

@@ -27,14 +27,14 @@ export type Three = {
   retry?: number | undefined;
 };
 
-export type Two = {
+export type ResponseBody2 = {
   event: "done";
   data?: string | null | undefined;
   id?: string | undefined;
   retry?: number | undefined;
 };
 
-export type One = {
+export type ResponseBody1 = {
   event: "message";
   /**
    * Represents a streamed chunk of a chat completion response
@@ -48,8 +48,8 @@ export type One = {
  * OK
  */
 export type CreateChatCompletionStreamResponseBody =
-  | One
-  | Two
+  | ResponseBody1
+  | ResponseBody2
   | Three
   | discriminatedUnionTypes.Unknown<"event">;
 
@@ -152,15 +152,18 @@ export function threeFromJSON(
 }
 
 /** @internal */
-export const Two$inboundSchema: z.ZodType<Two, z.ZodTypeDef, unknown> = z
-  .object({
-    event: z.literal("done"),
-    data: z.nullable(z.string()).optional(),
-    id: z.string().optional(),
-    retry: z.number().int().optional(),
-  });
+export const ResponseBody2$inboundSchema: z.ZodType<
+  ResponseBody2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  event: z.literal("done"),
+  data: z.nullable(z.string()).optional(),
+  id: z.string().optional(),
+  retry: z.number().int().optional(),
+});
 /** @internal */
-export type Two$Outbound = {
+export type ResponseBody2$Outbound = {
   event: "done";
   data?: string | null | undefined;
   id?: string | undefined;
@@ -168,45 +171,51 @@ export type Two$Outbound = {
 };
 
 /** @internal */
-export const Two$outboundSchema: z.ZodType<Two$Outbound, z.ZodTypeDef, Two> = z
-  .object({
-    event: z.literal("done"),
-    data: z.nullable(z.string()).optional(),
-    id: z.string().optional(),
-    retry: z.number().int().optional(),
-  });
+export const ResponseBody2$outboundSchema: z.ZodType<
+  ResponseBody2$Outbound,
+  z.ZodTypeDef,
+  ResponseBody2
+> = z.object({
+  event: z.literal("done"),
+  data: z.nullable(z.string()).optional(),
+  id: z.string().optional(),
+  retry: z.number().int().optional(),
+});
 
-export function twoToJSON(two: Two): string {
-  return JSON.stringify(Two$outboundSchema.parse(two));
+export function responseBody2ToJSON(responseBody2: ResponseBody2): string {
+  return JSON.stringify(ResponseBody2$outboundSchema.parse(responseBody2));
 }
-export function twoFromJSON(
+export function responseBody2FromJSON(
   jsonString: string,
-): SafeParseResult<Two, SDKValidationError> {
+): SafeParseResult<ResponseBody2, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Two$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Two' from JSON`,
+    (x) => ResponseBody2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBody2' from JSON`,
   );
 }
 
 /** @internal */
-export const One$inboundSchema: z.ZodType<One, z.ZodTypeDef, unknown> = z
-  .object({
-    event: z.literal("message"),
-    data: z.unknown().transform((v, ctx) => {
-      if (typeof v !== "string") return v;
-      try {
-        return JSON.parse(v);
-      } catch (err) {
-        ctx.addIssue({ code: "custom", message: `malformed json: ${err}` });
-        return z.NEVER;
-      }
-    }).pipe(components.OpenAIChatCompletionChunk$inboundSchema),
-    id: z.string().optional(),
-    retry: z.number().int().optional(),
-  });
+export const ResponseBody1$inboundSchema: z.ZodType<
+  ResponseBody1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  event: z.literal("message"),
+  data: z.unknown().transform((v, ctx) => {
+    if (typeof v !== "string") return v;
+    try {
+      return JSON.parse(v);
+    } catch (err) {
+      ctx.addIssue({ code: "custom", message: `malformed json: ${err}` });
+      return z.NEVER;
+    }
+  }).pipe(components.OpenAIChatCompletionChunk$inboundSchema),
+  id: z.string().optional(),
+  retry: z.number().int().optional(),
+});
 /** @internal */
-export type One$Outbound = {
+export type ResponseBody1$Outbound = {
   event: "message";
   data: components.OpenAIChatCompletionChunk$Outbound;
   id?: string | undefined;
@@ -214,24 +223,27 @@ export type One$Outbound = {
 };
 
 /** @internal */
-export const One$outboundSchema: z.ZodType<One$Outbound, z.ZodTypeDef, One> = z
-  .object({
-    event: z.literal("message"),
-    data: components.OpenAIChatCompletionChunk$outboundSchema,
-    id: z.string().optional(),
-    retry: z.number().int().optional(),
-  });
+export const ResponseBody1$outboundSchema: z.ZodType<
+  ResponseBody1$Outbound,
+  z.ZodTypeDef,
+  ResponseBody1
+> = z.object({
+  event: z.literal("message"),
+  data: components.OpenAIChatCompletionChunk$outboundSchema,
+  id: z.string().optional(),
+  retry: z.number().int().optional(),
+});
 
-export function oneToJSON(one: One): string {
-  return JSON.stringify(One$outboundSchema.parse(one));
+export function responseBody1ToJSON(responseBody1: ResponseBody1): string {
+  return JSON.stringify(ResponseBody1$outboundSchema.parse(responseBody1));
 }
-export function oneFromJSON(
+export function responseBody1FromJSON(
   jsonString: string,
-): SafeParseResult<One, SDKValidationError> {
+): SafeParseResult<ResponseBody1, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => One$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'One' from JSON`,
+    (x) => ResponseBody1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBody1' from JSON`,
   );
 }
 
@@ -241,14 +253,14 @@ export const CreateChatCompletionStreamResponseBody$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = discriminatedUnion("event", {
-  message: z.lazy(() => One$inboundSchema),
-  done: z.lazy(() => Two$inboundSchema),
+  message: z.lazy(() => ResponseBody1$inboundSchema),
+  done: z.lazy(() => ResponseBody2$inboundSchema),
   error: z.lazy(() => Three$inboundSchema),
 });
 /** @internal */
 export type CreateChatCompletionStreamResponseBody$Outbound =
-  | One$Outbound
-  | Two$Outbound
+  | ResponseBody1$Outbound
+  | ResponseBody2$Outbound
   | Three$Outbound;
 
 /** @internal */
@@ -257,8 +269,8 @@ export const CreateChatCompletionStreamResponseBody$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   CreateChatCompletionStreamResponseBody
 > = z.union([
-  z.lazy(() => One$outboundSchema),
-  z.lazy(() => Two$outboundSchema),
+  z.lazy(() => ResponseBody1$outboundSchema),
+  z.lazy(() => ResponseBody2$outboundSchema),
   z.lazy(() => Three$outboundSchema),
 ]);
 

package/src/models/operations/getorgtokenquota.ts

@@ -0,0 +1,145 @@
+/*
+ * 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 type GetOrgTokenQuotaRequest = {
+  orgId: string;
+};
+
+export const GetOrgTokenQuotaPeriod = {
+  Minute: "minute",
+  Day: "day",
+  Month: "month",
+} as const;
+export type GetOrgTokenQuotaPeriod = ClosedEnum<typeof GetOrgTokenQuotaPeriod>;
+
+/**
+ * OK
+ */
+export type GetOrgTokenQuotaResponseBody = {
+  orgId: string;
+  enabled: boolean;
+  limit: number | null;
+  period: GetOrgTokenQuotaPeriod | null;
+};
+
+/** @internal */
+export const GetOrgTokenQuotaRequest$inboundSchema: z.ZodType<
+  GetOrgTokenQuotaRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  org_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "org_id": "orgId",
+  });
+});
+/** @internal */
+export type GetOrgTokenQuotaRequest$Outbound = {
+  org_id: string;
+};
+
+/** @internal */
+export const GetOrgTokenQuotaRequest$outboundSchema: z.ZodType<
+  GetOrgTokenQuotaRequest$Outbound,
+  z.ZodTypeDef,
+  GetOrgTokenQuotaRequest
+> = z.object({
+  orgId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    orgId: "org_id",
+  });
+});
+
+export function getOrgTokenQuotaRequestToJSON(
+  getOrgTokenQuotaRequest: GetOrgTokenQuotaRequest,
+): string {
+  return JSON.stringify(
+    GetOrgTokenQuotaRequest$outboundSchema.parse(getOrgTokenQuotaRequest),
+  );
+}
+export function getOrgTokenQuotaRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<GetOrgTokenQuotaRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetOrgTokenQuotaRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetOrgTokenQuotaRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetOrgTokenQuotaPeriod$inboundSchema: z.ZodNativeEnum<
+  typeof GetOrgTokenQuotaPeriod
+> = z.nativeEnum(GetOrgTokenQuotaPeriod);
+/** @internal */
+export const GetOrgTokenQuotaPeriod$outboundSchema: z.ZodNativeEnum<
+  typeof GetOrgTokenQuotaPeriod
+> = GetOrgTokenQuotaPeriod$inboundSchema;
+
+/** @internal */
+export const GetOrgTokenQuotaResponseBody$inboundSchema: z.ZodType<
+  GetOrgTokenQuotaResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  org_id: z.string(),
+  enabled: z.boolean(),
+  limit: z.nullable(z.number().int()),
+  period: z.nullable(GetOrgTokenQuotaPeriod$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "org_id": "orgId",
+  });
+});
+/** @internal */
+export type GetOrgTokenQuotaResponseBody$Outbound = {
+  org_id: string;
+  enabled: boolean;
+  limit: number | null;
+  period: string | null;
+};
+
+/** @internal */
+export const GetOrgTokenQuotaResponseBody$outboundSchema: z.ZodType<
+  GetOrgTokenQuotaResponseBody$Outbound,
+  z.ZodTypeDef,
+  GetOrgTokenQuotaResponseBody
+> = z.object({
+  orgId: z.string(),
+  enabled: z.boolean(),
+  limit: z.nullable(z.number().int()),
+  period: z.nullable(GetOrgTokenQuotaPeriod$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    orgId: "org_id",
+  });
+});
+
+export function getOrgTokenQuotaResponseBodyToJSON(
+  getOrgTokenQuotaResponseBody: GetOrgTokenQuotaResponseBody,
+): string {
+  return JSON.stringify(
+    GetOrgTokenQuotaResponseBody$outboundSchema.parse(
+      getOrgTokenQuotaResponseBody,
+    ),
+  );
+}
+export function getOrgTokenQuotaResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetOrgTokenQuotaResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetOrgTokenQuotaResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetOrgTokenQuotaResponseBody' from JSON`,
+  );
+}

package/src/models/operations/index.ts

@@ -224,6 +224,7 @@ export * from "./getorgbudgets.js";
 export * from "./getorgbyid.js";
 export * from "./getorgquota.js";
 export * from "./getorgratelimit.js";
+export * from "./getorgtokenquota.js";
 export * from "./getpendinginvitation.js";
 export * from "./getpricing.js";
 export * from "./getprompt.js";
@@ -405,6 +406,7 @@ export * from "./setfeatureflagenvironmentstate.js";
 export * from "./setorganizationbillingenabled.js";
 export * from "./setorgbudget.js";
 export * from "./setorgprice.js";
+export * from "./setorgtokenquota.js";
 export * from "./setsandboxconnectorapikey.js";
 export * from "./setsandboxconnectortools.js";
 export * from "./setteambudget.js";

package/src/models/operations/listbudgets.ts

@@ -27,12 +27,12 @@ export const DataOwner = {
 } as const;
 export type DataOwner = ClosedEnum<typeof DataOwner>;
 
-export const DataPeriod = {
+export const ListBudgetsDataPeriod = {
   Daily: "daily",
   Weekly: "weekly",
   Monthly: "monthly",
 } as const;
-export type DataPeriod = ClosedEnum<typeof DataPeriod>;
+export type ListBudgetsDataPeriod = ClosedEnum<typeof ListBudgetsDataPeriod>;
 
 export const DataAction = {
   Alert: "alert",
@@ -51,7 +51,7 @@ export type Data2 = {
   scopeId: string;
   scopeOrgId: string | null;
   owner: DataOwner;
-  period: DataPeriod;
+  period: ListBudgetsDataPeriod;
   limit: number;
   thresholds: Array<DataThresholds>;
   alertWebhookUrl: string | null;
@@ -75,12 +75,12 @@ export const ListBudgetsDataOwner = {
 } as const;
 export type ListBudgetsDataOwner = ClosedEnum<typeof ListBudgetsDataOwner>;
 
-export const ListBudgetsDataPeriod = {
+export const DataPeriod = {
   Daily: "daily",
   Weekly: "weekly",
   Monthly: "monthly",
 } as const;
-export type ListBudgetsDataPeriod = ClosedEnum<typeof ListBudgetsDataPeriod>;
+export type DataPeriod = ClosedEnum<typeof DataPeriod>;
 
 export const ListBudgetsDataAction = {
   Alert: "alert",
@@ -119,7 +119,7 @@ export type Data1 = {
   scopeId: string;
   scopeOrgId: string | null;
   owner: ListBudgetsDataOwner;
-  period: ListBudgetsDataPeriod;
+  period: DataPeriod;
   limit: number;
   thresholds: Array<ListBudgetsDataThresholds>;
   alertWebhookUrl: string | null;
@@ -153,11 +153,13 @@ export const DataOwner$outboundSchema: z.ZodNativeEnum<typeof DataOwner> =
   DataOwner$inboundSchema;
 
 /** @internal */
-export const DataPeriod$inboundSchema: z.ZodNativeEnum<typeof DataPeriod> = z
-  .nativeEnum(DataPeriod);
+export const ListBudgetsDataPeriod$inboundSchema: z.ZodNativeEnum<
+  typeof ListBudgetsDataPeriod
+> = z.nativeEnum(ListBudgetsDataPeriod);
 /** @internal */
-export const DataPeriod$outboundSchema: z.ZodNativeEnum<typeof DataPeriod> =
-  DataPeriod$inboundSchema;
+export const ListBudgetsDataPeriod$outboundSchema: z.ZodNativeEnum<
+  typeof ListBudgetsDataPeriod
+> = ListBudgetsDataPeriod$inboundSchema;
 
 /** @internal */
 export const DataAction$inboundSchema: z.ZodNativeEnum<typeof DataAction> = z
@@ -212,7 +214,7 @@ export const Data2$inboundSchema: z.ZodType<Data2, z.ZodTypeDef, unknown> = z
     scope_id: z.string(),
     scope_org_id: z.nullable(z.string()),
     owner: DataOwner$inboundSchema,
-    period: DataPeriod$inboundSchema,
+    period: ListBudgetsDataPeriod$inboundSchema,
     limit: z.number(),
     thresholds: z.array(z.lazy(() => DataThresholds$inboundSchema)),
     alert_webhook_url: z.nullable(z.string()),
@@ -247,7 +249,7 @@ export const Data2$outboundSchema: z.ZodType<
   scopeId: z.string(),
   scopeOrgId: z.nullable(z.string()),
   owner: DataOwner$outboundSchema,
-  period: DataPeriod$outboundSchema,
+  period: ListBudgetsDataPeriod$outboundSchema,
   limit: z.number(),
   thresholds: z.array(z.lazy(() => DataThresholds$outboundSchema)),
   alertWebhookUrl: z.nullable(z.string()),
@@ -289,13 +291,11 @@ export const ListBudgetsDataOwner$outboundSchema: z.ZodNativeEnum<
 > = ListBudgetsDataOwner$inboundSchema;
 
 /** @internal */
-export const ListBudgetsDataPeriod$inboundSchema: z.ZodNativeEnum<
-  typeof ListBudgetsDataPeriod
-> = z.nativeEnum(ListBudgetsDataPeriod);
+export const DataPeriod$inboundSchema: z.ZodNativeEnum<typeof DataPeriod> = z
+  .nativeEnum(DataPeriod);
 /** @internal */
-export const ListBudgetsDataPeriod$outboundSchema: z.ZodNativeEnum<
-  typeof ListBudgetsDataPeriod
-> = ListBudgetsDataPeriod$inboundSchema;
+export const DataPeriod$outboundSchema: z.ZodNativeEnum<typeof DataPeriod> =
+  DataPeriod$inboundSchema;
 
 /** @internal */
 export const ListBudgetsDataAction$inboundSchema: z.ZodNativeEnum<
@@ -418,7 +418,7 @@ export const Data1$inboundSchema: z.ZodType<Data1, z.ZodTypeDef, unknown> = z
     scope_id: z.string(),
     scope_org_id: z.nullable(z.string()),
     owner: ListBudgetsDataOwner$inboundSchema,
-    period: ListBudgetsDataPeriod$inboundSchema,
+    period: DataPeriod$inboundSchema,
     limit: z.number(),
     thresholds: z.array(z.lazy(() => ListBudgetsDataThresholds$inboundSchema)),
     alert_webhook_url: z.nullable(z.string()),
@@ -455,7 +455,7 @@ export const Data1$outboundSchema: z.ZodType<
   scopeId: z.string(),
   scopeOrgId: z.nullable(z.string()),
   owner: ListBudgetsDataOwner$outboundSchema,
-  period: ListBudgetsDataPeriod$outboundSchema,
+  period: DataPeriod$outboundSchema,
   limit: z.number(),
   thresholds: z.array(z.lazy(() => ListBudgetsDataThresholds$outboundSchema)),
   alertWebhookUrl: z.nullable(z.string()),