@orq-ai/node 4.14.0-rc.20 → 4.14.0-rc.37

package/src/models/operations/streamrunagent.ts

@@ -3953,7 +3953,7 @@ export const AgentToolInputRunTools$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   AgentToolInputRunTools
 > = z.object({
-  id: z.string().default("01M06YQWFQGYPPET4X7BP5VGDQ"),
+  id: z.string().default("01M0CTRJRQYN7A7FST0KEPV5WM"),
   name: z.string(),
   description: z.string().optional(),
   schema: z.lazy(() =>

package/src/models/operations/updateannotationqueue.ts

@@ -195,7 +195,7 @@ export const UpdateAnnotationQueueResponseBody$inboundSchema: z.ZodType<
   created: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   updated: z.string().datetime({ offset: true }).default(
-    "2026-08-17T04:12:25.936Z",
+    "2026-08-19T10:58:01.279Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {

package/src/models/operations/updatechunk.ts

@@ -4,153 +4,21 @@
 
 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 UpdateChunkMetadata = string | number | boolean;
-
-export type UpdateChunkRequestBody = {
-  /**
-   * The text content of the chunk
-   */
-  text?: string | undefined;
-  /**
-   * The embedding vector of the chunk. If not provided the chunk will be embedded with the knowledge base embeddings model.
-   */
-  embedding?: Array<number> | undefined;
-  /**
-   * Metadata of the chunk
-   */
-  metadata?: { [k: string]: string | number | boolean } | undefined;
-};
+import * as components from "../components/index.js";
 
 export type UpdateChunkRequest = {
-  /**
-   * The unique identifier of the chunk
-   */
-  chunkId: string;
-  /**
-   * The unique identifier of the data source
-   */
-  datasourceId: string;
-  /**
-   * The unique identifier of the knowledge base
-   */
   knowledgeId: string;
-  requestBody?: UpdateChunkRequestBody | undefined;
-};
-
-export type UpdateChunkKnowledgeMetadata = string | number | boolean;
-
-/**
- * The status of the chunk
- */
-export const UpdateChunkStatus = {
-  Pending: "pending",
-  Processing: "processing",
-  Completed: "completed",
-  Failed: "failed",
-  Queued: "queued",
-} as const;
-/**
- * The status of the chunk
- */
-export type UpdateChunkStatus = ClosedEnum<typeof UpdateChunkStatus>;
-
-/**
- * Chunk successfully updated
- */
-export type UpdateChunkResponseBody = {
-  /**
-   * The unique identifier of the chunk
-   */
-  id: string;
-  /**
-   * The text content of the chunk
-   */
-  text: string;
-  /**
-   * Metadata of the chunk. Can include `page_number` or any other key-value pairs
-   */
-  metadata?: { [k: string]: string | number | boolean } | undefined;
-  /**
-   * Whether the chunk is enabled
-   */
-  enabled: boolean;
-  /**
-   * The status of the chunk
-   */
-  status: UpdateChunkStatus;
-  /**
-   * The date and time the chunk was created
-   */
-  created: string;
-  /**
-   * The date and time the chunk was updated
-   */
-  updated: string;
-  /**
-   * The unique identifier of the user who created the chunk
-   */
-  createdById?: string | null | undefined;
-  /**
-   * The unique identifier of the user who updated the chunk
-   */
-  updateById?: string | null | undefined;
-};
-
-/** @internal */
-export type UpdateChunkMetadata$Outbound = string | number | boolean;
-
-/** @internal */
-export const UpdateChunkMetadata$outboundSchema: z.ZodType<
-  UpdateChunkMetadata$Outbound,
-  z.ZodTypeDef,
-  UpdateChunkMetadata
-> = z.union([z.string(), z.number(), z.boolean()]);
-
-export function updateChunkMetadataToJSON(
-  updateChunkMetadata: UpdateChunkMetadata,
-): string {
-  return JSON.stringify(
-    UpdateChunkMetadata$outboundSchema.parse(updateChunkMetadata),
-  );
-}
-
-/** @internal */
-export type UpdateChunkRequestBody$Outbound = {
-  text?: string | undefined;
-  embedding?: Array<number> | undefined;
-  metadata?: { [k: string]: string | number | boolean } | undefined;
+  datasourceId: string;
+  chunkId: string;
+  chunksServiceUpdateRequest: components.ChunksServiceUpdateRequest;
 };
 
-/** @internal */
-export const UpdateChunkRequestBody$outboundSchema: z.ZodType<
-  UpdateChunkRequestBody$Outbound,
-  z.ZodTypeDef,
-  UpdateChunkRequestBody
-> = z.object({
-  text: z.string().optional(),
-  embedding: z.array(z.number()).optional(),
-  metadata: z.record(z.union([z.string(), z.number(), z.boolean()])).optional(),
-});
-
-export function updateChunkRequestBodyToJSON(
-  updateChunkRequestBody: UpdateChunkRequestBody,
-): string {
-  return JSON.stringify(
-    UpdateChunkRequestBody$outboundSchema.parse(updateChunkRequestBody),
-  );
-}
-
 /** @internal */
 export type UpdateChunkRequest$Outbound = {
-  chunk_id: string;
-  datasource_id: string;
   knowledge_id: string;
-  RequestBody?: UpdateChunkRequestBody$Outbound | undefined;
+  datasource_id: string;
+  chunk_id: string;
+  ChunksServiceUpdateRequest: components.ChunksServiceUpdateRequest$Outbound;
 };
 
 /** @internal */
@@ -159,16 +27,17 @@ export const UpdateChunkRequest$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   UpdateChunkRequest
 > = z.object({
-  chunkId: z.string(),
-  datasourceId: z.string(),
   knowledgeId: z.string(),
-  requestBody: z.lazy(() => UpdateChunkRequestBody$outboundSchema).optional(),
+  datasourceId: z.string(),
+  chunkId: z.string(),
+  chunksServiceUpdateRequest:
+    components.ChunksServiceUpdateRequest$outboundSchema,
 }).transform((v) => {
   return remap$(v, {
-    chunkId: "chunk_id",
-    datasourceId: "datasource_id",
     knowledgeId: "knowledge_id",
-    requestBody: "RequestBody",
+    datasourceId: "datasource_id",
+    chunkId: "chunk_id",
+    chunksServiceUpdateRequest: "ChunksServiceUpdateRequest",
   });
 });
 
@@ -179,58 +48,3 @@ export function updateChunkRequestToJSON(
     UpdateChunkRequest$outboundSchema.parse(updateChunkRequest),
   );
 }
-
-/** @internal */
-export const UpdateChunkKnowledgeMetadata$inboundSchema: z.ZodType<
-  UpdateChunkKnowledgeMetadata,
-  z.ZodTypeDef,
-  unknown
-> = z.union([z.string(), z.number(), z.boolean()]);
-
-export function updateChunkKnowledgeMetadataFromJSON(
-  jsonString: string,
-): SafeParseResult<UpdateChunkKnowledgeMetadata, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => UpdateChunkKnowledgeMetadata$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'UpdateChunkKnowledgeMetadata' from JSON`,
-  );
-}
-
-/** @internal */
-export const UpdateChunkStatus$inboundSchema: z.ZodNativeEnum<
-  typeof UpdateChunkStatus
-> = z.nativeEnum(UpdateChunkStatus);
-
-/** @internal */
-export const UpdateChunkResponseBody$inboundSchema: z.ZodType<
-  UpdateChunkResponseBody,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  _id: z.string(),
-  text: z.string(),
-  metadata: z.record(z.union([z.string(), z.number(), z.boolean()])).optional(),
-  enabled: z.boolean(),
-  status: UpdateChunkStatus$inboundSchema,
-  created: z.string(),
-  updated: z.string(),
-  created_by_id: z.nullable(z.string()).optional(),
-  update_by_id: z.nullable(z.string()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "_id": "id",
-    "created_by_id": "createdById",
-    "update_by_id": "updateById",
-  });
-});
-
-export function updateChunkResponseBodyFromJSON(
-  jsonString: string,
-): SafeParseResult<UpdateChunkResponseBody, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => UpdateChunkResponseBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'UpdateChunkResponseBody' from JSON`,
-  );
-}

package/src/models/operations/updatechunkenabled.ts

@@ -0,0 +1,51 @@
+/*
+ * 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 * as components from "../components/index.js";
+
+export type UpdateChunkEnabledRequest = {
+  knowledgeId: string;
+  datasourceId: string;
+  chunkId: string;
+  chunksServiceSetEnabledRequest: components.ChunksServiceSetEnabledRequest;
+};
+
+/** @internal */
+export type UpdateChunkEnabledRequest$Outbound = {
+  knowledge_id: string;
+  datasource_id: string;
+  chunk_id: string;
+  ChunksServiceSetEnabledRequest:
+    components.ChunksServiceSetEnabledRequest$Outbound;
+};
+
+/** @internal */
+export const UpdateChunkEnabledRequest$outboundSchema: z.ZodType<
+  UpdateChunkEnabledRequest$Outbound,
+  z.ZodTypeDef,
+  UpdateChunkEnabledRequest
+> = z.object({
+  knowledgeId: z.string(),
+  datasourceId: z.string(),
+  chunkId: z.string(),
+  chunksServiceSetEnabledRequest:
+    components.ChunksServiceSetEnabledRequest$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    knowledgeId: "knowledge_id",
+    datasourceId: "datasource_id",
+    chunkId: "chunk_id",
+    chunksServiceSetEnabledRequest: "ChunksServiceSetEnabledRequest",
+  });
+});
+
+export function updateChunkEnabledRequestToJSON(
+  updateChunkEnabledRequest: UpdateChunkEnabledRequest,
+): string {
+  return JSON.stringify(
+    UpdateChunkEnabledRequest$outboundSchema.parse(updateChunkEnabledRequest),
+  );
+}

package/src/models/operations/updatedatapoint.ts

@@ -2747,7 +2747,7 @@ export const UpdateDatapointEvaluations4$inboundSchema: z.ZodType<
   explanation: z.string().optional(),
   reviewed_by_id: z.string(),
   reviewed_at: z.string().datetime({ offset: true }).default(
-    "2026-08-17T04:12:42.232Z",
+    "2026-08-19T10:58:37.137Z",
   ).transform(v => new Date(v)),
   type: z.literal("string_array"),
   values: z.array(z.string()),
@@ -2847,7 +2847,7 @@ export const UpdateDatapointEvaluations3$inboundSchema: z.ZodType<
   explanation: z.string().optional(),
   reviewed_by_id: z.string(),
   reviewed_at: z.string().datetime({ offset: true }).default(
-    "2026-08-17T04:12:42.232Z",
+    "2026-08-19T10:58:37.137Z",
   ).transform(v => new Date(v)),
   type: z.literal("boolean"),
   value: z.boolean(),
@@ -2944,7 +2944,7 @@ export const UpdateDatapointEvaluations2$inboundSchema: z.ZodType<
   explanation: z.string().optional(),
   reviewed_by_id: z.string(),
   reviewed_at: z.string().datetime({ offset: true }).default(
-    "2026-08-17T04:12:42.231Z",
+    "2026-08-19T10:58:37.136Z",
   ).transform(v => new Date(v)),
   type: z.literal("number"),
   value: z.number(),
@@ -3033,7 +3033,7 @@ export const UpdateDatapointEvaluations1$inboundSchema: z.ZodType<
   explanation: z.string().optional(),
   reviewed_by_id: z.string(),
   reviewed_at: z.string().datetime({ offset: true }).default(
-    "2026-08-17T04:12:42.230Z",
+    "2026-08-19T10:58:37.136Z",
   ).transform(v => new Date(v)),
   type: z.literal("string"),
   value: z.string(),
@@ -3118,7 +3118,7 @@ export const UpdateDatapointResponseBody$inboundSchema: z.ZodType<
   created: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   updated: z.string().datetime({ offset: true }).default(
-    "2026-08-17T04:12:25.936Z",
+    "2026-08-19T10:58:01.279Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {

package/src/models/operations/updatedataset.ts

@@ -182,7 +182,7 @@ export const UpdateDatasetResponseBody$inboundSchema: z.ZodType<
   created: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   updated: z.string().datetime({ offset: true }).default(
-    "2026-08-17T04:12:25.936Z",
+    "2026-08-19T10:58:01.279Z",
   ).transform(v => new Date(v)),
 }).transform((v) => {
   return remap$(v, {

package/src/models/operations/updatedatasource.ts

@@ -4,148 +4,20 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
-import {
-  collectExtraKeys as collectExtraKeys$,
-  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 UpdateDatasourceRequestBody = {
-  displayName: string;
-};
+import * as components from "../components/index.js";
 
 export type UpdateDatasourceRequest = {
-  /**
-   * The unique identifier of the knowledge base
-   */
   knowledgeId: string;
-  /**
-   * The unique identifier of the datasource.
-   */
   datasourceId: string;
-  requestBody: UpdateDatasourceRequestBody;
-};
-
-export const UpdateDatasourceStatus = {
-  Pending: "pending",
-  Processing: "processing",
-  Completed: "completed",
-  Failed: "failed",
-  Queued: "queued",
-} as const;
-export type UpdateDatasourceStatus = ClosedEnum<typeof UpdateDatasourceStatus>;
-
-export type UpdateDatasourceMetadata = {
-  /**
-   * Number of words in the text
-   */
-  wordsCount?: number | undefined;
-  /**
-   * Number of sentences in the text
-   */
-  sentencesCount?: number | undefined;
-  /**
-   * Number of paragraphs in the text
-   */
-  paragraphsCount?: number | undefined;
-  /**
-   * Number of tokens in the text
-   */
-  tokensCount?: number | undefined;
-  /**
-   * Number of characters in the text
-   */
-  charactersCount?: number | undefined;
-  /**
-   * Number of total chunks
-   */
-  chunksCount?: number | undefined;
-  additionalProperties?: { [k: string]: any } | undefined;
-};
-
-/**
- * Datasource successfully updated
- */
-export type UpdateDatasourceResponseBody = {
-  /**
-   * The unique identifier of the data source
-   */
-  id: string;
-  /**
-   * The display name of the datasource. Normally the name of the uploaded file
-   */
-  displayName: string;
-  /**
-   * The description of the knowledge base
-   */
-  description?: string | null | undefined;
-  status: UpdateDatasourceStatus;
-  /**
-   * The unique identifier of the file used to create the datasource.
-   */
-  fileId?: string | null | undefined;
-  /**
-   * The date and time the datasource was created
-   */
-  created: string;
-  /**
-   * The date and time the datasource was updated
-   */
-  updated: string;
-  /**
-   * The user ID of the creator of the knowledge base
-   */
-  createdById?: string | null | undefined;
-  /**
-   * The user ID of the last user who updated the knowledge base
-   */
-  updateById?: string | null | undefined;
-  /**
-   * The unique identifier of the knowledge base
-   */
-  knowledgeId: string;
-  /**
-   * The number of chunks in the datasource
-   */
-  chunksCount: number;
-  metadata: UpdateDatasourceMetadata;
-};
-
-/** @internal */
-export type UpdateDatasourceRequestBody$Outbound = {
-  display_name: string;
+  datasourcesServiceUpdateRequest: components.DatasourcesServiceUpdateRequest;
 };
 
-/** @internal */
-export const UpdateDatasourceRequestBody$outboundSchema: z.ZodType<
-  UpdateDatasourceRequestBody$Outbound,
-  z.ZodTypeDef,
-  UpdateDatasourceRequestBody
-> = z.object({
-  displayName: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    displayName: "display_name",
-  });
-});
-
-export function updateDatasourceRequestBodyToJSON(
-  updateDatasourceRequestBody: UpdateDatasourceRequestBody,
-): string {
-  return JSON.stringify(
-    UpdateDatasourceRequestBody$outboundSchema.parse(
-      updateDatasourceRequestBody,
-    ),
-  );
-}
-
 /** @internal */
 export type UpdateDatasourceRequest$Outbound = {
   knowledge_id: string;
   datasource_id: string;
-  RequestBody: UpdateDatasourceRequestBody$Outbound;
+  DatasourcesServiceUpdateRequest:
+    components.DatasourcesServiceUpdateRequest$Outbound;
 };
 
 /** @internal */
@@ -156,12 +28,13 @@ export const UpdateDatasourceRequest$outboundSchema: z.ZodType<
 > = z.object({
   knowledgeId: z.string(),
   datasourceId: z.string(),
-  requestBody: z.lazy(() => UpdateDatasourceRequestBody$outboundSchema),
+  datasourcesServiceUpdateRequest:
+    components.DatasourcesServiceUpdateRequest$outboundSchema,
 }).transform((v) => {
   return remap$(v, {
     knowledgeId: "knowledge_id",
     datasourceId: "datasource_id",
-    requestBody: "RequestBody",
+    datasourcesServiceUpdateRequest: "DatasourcesServiceUpdateRequest",
   });
 });
 
@@ -172,85 +45,3 @@ export function updateDatasourceRequestToJSON(
     UpdateDatasourceRequest$outboundSchema.parse(updateDatasourceRequest),
   );
 }
-
-/** @internal */
-export const UpdateDatasourceStatus$inboundSchema: z.ZodNativeEnum<
-  typeof UpdateDatasourceStatus
-> = z.nativeEnum(UpdateDatasourceStatus);
-
-/** @internal */
-export const UpdateDatasourceMetadata$inboundSchema: z.ZodType<
-  UpdateDatasourceMetadata,
-  z.ZodTypeDef,
-  unknown
-> = collectExtraKeys$(
-  z.object({
-    words_count: z.number().optional(),
-    sentences_count: z.number().optional(),
-    paragraphs_count: z.number().optional(),
-    tokens_count: z.number().optional(),
-    characters_count: z.number().optional(),
-    chunks_count: z.number().optional(),
-  }).catchall(z.any()),
-  "additionalProperties",
-  true,
-).transform((v) => {
-  return remap$(v, {
-    "words_count": "wordsCount",
-    "sentences_count": "sentencesCount",
-    "paragraphs_count": "paragraphsCount",
-    "tokens_count": "tokensCount",
-    "characters_count": "charactersCount",
-    "chunks_count": "chunksCount",
-  });
-});
-
-export function updateDatasourceMetadataFromJSON(
-  jsonString: string,
-): SafeParseResult<UpdateDatasourceMetadata, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => UpdateDatasourceMetadata$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'UpdateDatasourceMetadata' from JSON`,
-  );
-}
-
-/** @internal */
-export const UpdateDatasourceResponseBody$inboundSchema: z.ZodType<
-  UpdateDatasourceResponseBody,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  _id: z.string().default("01M06YQWRHDWMBYBEZXCFPQP69"),
-  display_name: z.string(),
-  description: z.nullable(z.string()).optional(),
-  status: UpdateDatasourceStatus$inboundSchema,
-  file_id: z.nullable(z.string()).optional(),
-  created: z.string(),
-  updated: z.string(),
-  created_by_id: z.nullable(z.string()).optional(),
-  update_by_id: z.nullable(z.string()).optional(),
-  knowledge_id: z.string(),
-  chunks_count: z.number(),
-  metadata: z.lazy(() => UpdateDatasourceMetadata$inboundSchema),
-}).transform((v) => {
-  return remap$(v, {
-    "_id": "id",
-    "display_name": "displayName",
-    "file_id": "fileId",
-    "created_by_id": "createdById",
-    "update_by_id": "updateById",
-    "knowledge_id": "knowledgeId",
-    "chunks_count": "chunksCount",
-  });
-});
-
-export function updateDatasourceResponseBodyFromJSON(
-  jsonString: string,
-): SafeParseResult<UpdateDatasourceResponseBody, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => UpdateDatasourceResponseBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'UpdateDatasourceResponseBody' from JSON`,
-  );
-}