@orq-ai/node 4.2.0-rc.4 → 4.2.0-rc.40

package/src/models/operations/listidentities.ts

@@ -0,0 +1,432 @@
+/*
+ * 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";
+
+/**
+ * Filter identities by tags. Can be provided as JSON object {"tags": ["premium", "beta-user"]} or as query format "tags=premium,beta-user"
+ */
+export type QueryParamFilterBy = {
+  tags?: Array<string> | undefined;
+};
+
+export type ListIdentitiesRequest = {
+  /**
+   * A limit on the number of objects to be returned. Limit can range between 1 and 50, and the default is 10
+   */
+  limit?: number | undefined;
+  /**
+   * A cursor for use in pagination. `starting_after` is an object ID that defines your place in the list. For instance, if you make a list request and receive 20 objects, ending with `01JJ1HDHN79XAS7A01WB3HYSDB`, your subsequent call can include `after=01JJ1HDHN79XAS7A01WB3HYSDB` in order to fetch the next page of the list.
+   */
+  startingAfter?: string | undefined;
+  /**
+   * A cursor for use in pagination. `ending_before` is an object ID that defines your place in the list. For instance, if you make a list request and receive 20 objects, starting with `01JJ1HDHN79XAS7A01WB3HYSDB`, your subsequent call can include `before=01JJ1HDHN79XAS7A01WB3HYSDB` in order to fetch the previous page of the list.
+   */
+  endingBefore?: string | undefined;
+  /**
+   * Search identities by display name or email address. Minimum 2 characters required.
+   */
+  search?: string | undefined;
+  /**
+   * Filter identities by tags. Can be provided as JSON object {"tags": ["premium", "beta-user"]} or as query format "tags=premium,beta-user"
+   */
+  filterBy?: QueryParamFilterBy | undefined;
+  /**
+   * Include usage metrics of the last 30 days for each identity.
+   */
+  includeMetrics?: boolean | null | undefined;
+};
+
+export const ListIdentitiesObject = {
+  List: "list",
+} as const;
+export type ListIdentitiesObject = ClosedEnum<typeof ListIdentitiesObject>;
+
+export type ListIdentitiesMetrics = {
+  /**
+   * Total cost in dollars of the last 30 days
+   */
+  totalCost: number;
+  /**
+   * Total tokens of the last 30 days
+   */
+  totalTokens: number;
+  /**
+   * Total requests of the last 30 days
+   */
+  totalRequests: number;
+  /**
+   * P50 error rate of the last 30 days
+   */
+  errorRate: number;
+};
+
+export type ListIdentitiesData = {
+  /**
+   * Unique ULID (Universally Unique Lexicographically Sortable Identifier) for the contact
+   */
+  id: string;
+  /**
+   * Unique string value to identify the contact user in the customer's system. This should be the same ID you use in your system to reference this user.
+   */
+  externalId: string;
+  /**
+   * Display name or nickname of the contact user. This is typically shown in user interfaces.
+   */
+  displayName?: string | null | undefined;
+  /**
+   * Email address of the contact user
+   */
+  email?: string | null | undefined;
+  /**
+   * URL linking to the contact user's avatar image
+   */
+  avatarUrl?: string | null | undefined;
+  /**
+   * Array of tags associated with the contact. Useful for organizing and filtering contacts by categories, departments, or custom classifications.
+   */
+  tags?: Array<string> | undefined;
+  /**
+   * Additional custom metadata associated with the contact as key-value pairs. Use this to store any extra information specific to your application.
+   */
+  metadata?: { [k: string]: any } | undefined;
+  /**
+   * The date and time the resource was created
+   */
+  created?: Date | undefined;
+  /**
+   * The date and time the resource was last updated
+   */
+  updated?: Date | undefined;
+  metrics: ListIdentitiesMetrics;
+};
+
+/**
+ * List of identities
+ */
+export type ListIdentitiesResponseBody = {
+  object: ListIdentitiesObject;
+  data: Array<ListIdentitiesData>;
+  hasMore: boolean;
+};
+
+/** @internal */
+export const QueryParamFilterBy$inboundSchema: z.ZodType<
+  QueryParamFilterBy,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  tags: z.array(z.string()).optional(),
+});
+/** @internal */
+export type QueryParamFilterBy$Outbound = {
+  tags?: Array<string> | undefined;
+};
+
+/** @internal */
+export const QueryParamFilterBy$outboundSchema: z.ZodType<
+  QueryParamFilterBy$Outbound,
+  z.ZodTypeDef,
+  QueryParamFilterBy
+> = z.object({
+  tags: z.array(z.string()).optional(),
+});
+
+export function queryParamFilterByToJSON(
+  queryParamFilterBy: QueryParamFilterBy,
+): string {
+  return JSON.stringify(
+    QueryParamFilterBy$outboundSchema.parse(queryParamFilterBy),
+  );
+}
+export function queryParamFilterByFromJSON(
+  jsonString: string,
+): SafeParseResult<QueryParamFilterBy, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => QueryParamFilterBy$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'QueryParamFilterBy' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListIdentitiesRequest$inboundSchema: z.ZodType<
+  ListIdentitiesRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  limit: z.number().default(10),
+  starting_after: z.string().optional(),
+  ending_before: z.string().optional(),
+  search: z.string().optional(),
+  filter_by: z.lazy(() => QueryParamFilterBy$inboundSchema).optional(),
+  include_metrics: z.nullable(z.boolean().default(false)),
+}).transform((v) => {
+  return remap$(v, {
+    "starting_after": "startingAfter",
+    "ending_before": "endingBefore",
+    "filter_by": "filterBy",
+    "include_metrics": "includeMetrics",
+  });
+});
+/** @internal */
+export type ListIdentitiesRequest$Outbound = {
+  limit: number;
+  starting_after?: string | undefined;
+  ending_before?: string | undefined;
+  search?: string | undefined;
+  filter_by?: QueryParamFilterBy$Outbound | undefined;
+  include_metrics: boolean | null;
+};
+
+/** @internal */
+export const ListIdentitiesRequest$outboundSchema: z.ZodType<
+  ListIdentitiesRequest$Outbound,
+  z.ZodTypeDef,
+  ListIdentitiesRequest
+> = z.object({
+  limit: z.number().default(10),
+  startingAfter: z.string().optional(),
+  endingBefore: z.string().optional(),
+  search: z.string().optional(),
+  filterBy: z.lazy(() => QueryParamFilterBy$outboundSchema).optional(),
+  includeMetrics: z.nullable(z.boolean().default(false)),
+}).transform((v) => {
+  return remap$(v, {
+    startingAfter: "starting_after",
+    endingBefore: "ending_before",
+    filterBy: "filter_by",
+    includeMetrics: "include_metrics",
+  });
+});
+
+export function listIdentitiesRequestToJSON(
+  listIdentitiesRequest: ListIdentitiesRequest,
+): string {
+  return JSON.stringify(
+    ListIdentitiesRequest$outboundSchema.parse(listIdentitiesRequest),
+  );
+}
+export function listIdentitiesRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<ListIdentitiesRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListIdentitiesRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListIdentitiesRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListIdentitiesObject$inboundSchema: z.ZodNativeEnum<
+  typeof ListIdentitiesObject
+> = z.nativeEnum(ListIdentitiesObject);
+/** @internal */
+export const ListIdentitiesObject$outboundSchema: z.ZodNativeEnum<
+  typeof ListIdentitiesObject
+> = ListIdentitiesObject$inboundSchema;
+
+/** @internal */
+export const ListIdentitiesMetrics$inboundSchema: z.ZodType<
+  ListIdentitiesMetrics,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  total_cost: z.number(),
+  total_tokens: z.number(),
+  total_requests: z.number(),
+  error_rate: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    "total_cost": "totalCost",
+    "total_tokens": "totalTokens",
+    "total_requests": "totalRequests",
+    "error_rate": "errorRate",
+  });
+});
+/** @internal */
+export type ListIdentitiesMetrics$Outbound = {
+  total_cost: number;
+  total_tokens: number;
+  total_requests: number;
+  error_rate: number;
+};
+
+/** @internal */
+export const ListIdentitiesMetrics$outboundSchema: z.ZodType<
+  ListIdentitiesMetrics$Outbound,
+  z.ZodTypeDef,
+  ListIdentitiesMetrics
+> = z.object({
+  totalCost: z.number(),
+  totalTokens: z.number(),
+  totalRequests: z.number(),
+  errorRate: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    totalCost: "total_cost",
+    totalTokens: "total_tokens",
+    totalRequests: "total_requests",
+    errorRate: "error_rate",
+  });
+});
+
+export function listIdentitiesMetricsToJSON(
+  listIdentitiesMetrics: ListIdentitiesMetrics,
+): string {
+  return JSON.stringify(
+    ListIdentitiesMetrics$outboundSchema.parse(listIdentitiesMetrics),
+  );
+}
+export function listIdentitiesMetricsFromJSON(
+  jsonString: string,
+): SafeParseResult<ListIdentitiesMetrics, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListIdentitiesMetrics$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListIdentitiesMetrics' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListIdentitiesData$inboundSchema: z.ZodType<
+  ListIdentitiesData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  _id: z.string(),
+  external_id: z.string(),
+  display_name: z.nullable(z.string()).optional(),
+  email: z.nullable(z.string()).optional(),
+  avatar_url: z.nullable(z.string()).optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.any()).optional(),
+  created: z.string().datetime({ offset: true }).transform(v => new Date(v))
+    .optional(),
+  updated: z.string().datetime({ offset: true }).default(
+    "2026-01-19T11:38:09.062Z",
+  ).transform(v => new Date(v)),
+  metrics: z.lazy(() => ListIdentitiesMetrics$inboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "external_id": "externalId",
+    "display_name": "displayName",
+    "avatar_url": "avatarUrl",
+  });
+});
+/** @internal */
+export type ListIdentitiesData$Outbound = {
+  _id: string;
+  external_id: string;
+  display_name?: string | null | undefined;
+  email?: string | null | undefined;
+  avatar_url?: string | null | undefined;
+  tags?: Array<string> | undefined;
+  metadata?: { [k: string]: any } | undefined;
+  created?: string | undefined;
+  updated: string;
+  metrics: ListIdentitiesMetrics$Outbound;
+};
+
+/** @internal */
+export const ListIdentitiesData$outboundSchema: z.ZodType<
+  ListIdentitiesData$Outbound,
+  z.ZodTypeDef,
+  ListIdentitiesData
+> = z.object({
+  id: z.string(),
+  externalId: z.string(),
+  displayName: z.nullable(z.string()).optional(),
+  email: z.nullable(z.string()).optional(),
+  avatarUrl: z.nullable(z.string()).optional(),
+  tags: z.array(z.string()).optional(),
+  metadata: z.record(z.any()).optional(),
+  created: z.date().transform(v => v.toISOString()).optional(),
+  updated: z.date().default(() => new Date("2026-01-19T11:38:09.062Z"))
+    .transform(v => v.toISOString()),
+  metrics: z.lazy(() => ListIdentitiesMetrics$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    id: "_id",
+    externalId: "external_id",
+    displayName: "display_name",
+    avatarUrl: "avatar_url",
+  });
+});
+
+export function listIdentitiesDataToJSON(
+  listIdentitiesData: ListIdentitiesData,
+): string {
+  return JSON.stringify(
+    ListIdentitiesData$outboundSchema.parse(listIdentitiesData),
+  );
+}
+export function listIdentitiesDataFromJSON(
+  jsonString: string,
+): SafeParseResult<ListIdentitiesData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListIdentitiesData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListIdentitiesData' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListIdentitiesResponseBody$inboundSchema: z.ZodType<
+  ListIdentitiesResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: ListIdentitiesObject$inboundSchema,
+  data: z.array(z.lazy(() => ListIdentitiesData$inboundSchema)),
+  has_more: z.boolean(),
+}).transform((v) => {
+  return remap$(v, {
+    "has_more": "hasMore",
+  });
+});
+/** @internal */
+export type ListIdentitiesResponseBody$Outbound = {
+  object: string;
+  data: Array<ListIdentitiesData$Outbound>;
+  has_more: boolean;
+};
+
+/** @internal */
+export const ListIdentitiesResponseBody$outboundSchema: z.ZodType<
+  ListIdentitiesResponseBody$Outbound,
+  z.ZodTypeDef,
+  ListIdentitiesResponseBody
+> = z.object({
+  object: ListIdentitiesObject$outboundSchema,
+  data: z.array(z.lazy(() => ListIdentitiesData$outboundSchema)),
+  hasMore: z.boolean(),
+}).transform((v) => {
+  return remap$(v, {
+    hasMore: "has_more",
+  });
+});
+
+export function listIdentitiesResponseBodyToJSON(
+  listIdentitiesResponseBody: ListIdentitiesResponseBody,
+): string {
+  return JSON.stringify(
+    ListIdentitiesResponseBody$outboundSchema.parse(listIdentitiesResponseBody),
+  );
+}
+export function listIdentitiesResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<ListIdentitiesResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListIdentitiesResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListIdentitiesResponseBody' from JSON`,
+  );
+}

package/src/models/operations/parse.ts

@@ -9,6 +9,64 @@ import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export const ParseChunkingRequestChunkingRequestRequestBodyReturnType = {
+  Chunks: "chunks",
+  Texts: "texts",
+} as const;
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ParseChunkingRequestChunkingRequestRequestBodyReturnType =
+  ClosedEnum<typeof ParseChunkingRequestChunkingRequestRequestBodyReturnType>;
+
+/**
+ * High-performance SIMD-optimized byte-level chunking. Best for large files (>1MB) where speed and memory efficiency are critical. 2x faster and 3x less memory than token-based chunking.
+ */
+export type FastChunkerStrategy = {
+  /**
+   * The text content to be chunked
+   */
+  text: string;
+  /**
+   * Whether to include metadata for each chunk
+   */
+  metadata?: boolean | undefined;
+  /**
+   * Return format: chunks (with metadata) or texts (plain strings)
+   */
+  returnType?:
+    | ParseChunkingRequestChunkingRequestRequestBodyReturnType
+    | undefined;
+  strategy: "fast";
+  /**
+   * Target chunk size in bytes
+   */
+  targetSize?: number | undefined;
+  /**
+   * Single-byte delimiter characters. Each character is treated as a separate delimiter (e.g., ".?!" splits on period, question mark, or exclamation). Use escaped sequences for special chars.
+   */
+  delimiters?: string | undefined;
+  /**
+   * Multi-byte pattern for splitting (e.g., "▁" for SentencePiece tokenizers). Takes precedence over delimiters if set.
+   */
+  pattern?: string | undefined;
+  /**
+   * Attach delimiter to start of next chunk instead of end of current chunk
+   */
+  prefix?: boolean | undefined;
+  /**
+   * When true, splits at the START of consecutive delimiter runs, keeping the run with the following chunk (e.g., splits before "\n\n\n" not in the middle)
+   */
+  consecutive?: boolean | undefined;
+  /**
+   * Search forward if no delimiter found in backward search window
+   */
+  forwardFallback?: boolean | undefined;
+};
+
 /**
  * Return format: chunks (with metadata) or texts (plain strings)
  */
@@ -278,7 +336,8 @@ export type ParseChunkingRequest =
   | SentenceChunkerStrategy
   | RecursiveChunkerStrategy
   | SemanticChunkerStrategy
-  | AgenticChunkerStrategy;
+  | AgenticChunkerStrategy
+  | FastChunkerStrategy;
 
 export type ParseMetadata = {
   startIndex: number | null;
@@ -305,6 +364,99 @@ export type ParseResponseBody = {
   chunks: Array<Chunks>;
 };
 
+/** @internal */
+export const ParseChunkingRequestChunkingRequestRequestBodyReturnType$inboundSchema:
+  z.ZodNativeEnum<
+    typeof ParseChunkingRequestChunkingRequestRequestBodyReturnType
+  > = z.nativeEnum(ParseChunkingRequestChunkingRequestRequestBodyReturnType);
+/** @internal */
+export const ParseChunkingRequestChunkingRequestRequestBodyReturnType$outboundSchema:
+  z.ZodNativeEnum<
+    typeof ParseChunkingRequestChunkingRequestRequestBodyReturnType
+  > = ParseChunkingRequestChunkingRequestRequestBodyReturnType$inboundSchema;
+
+/** @internal */
+export const FastChunkerStrategy$inboundSchema: z.ZodType<
+  FastChunkerStrategy,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  text: z.string(),
+  metadata: z.boolean().default(true),
+  return_type:
+    ParseChunkingRequestChunkingRequestRequestBodyReturnType$inboundSchema
+      .default("chunks"),
+  strategy: z.literal("fast"),
+  target_size: z.number().int().default(4096),
+  delimiters: z.string().default("\n.?"),
+  pattern: z.string().optional(),
+  prefix: z.boolean().default(false),
+  consecutive: z.boolean().default(false),
+  forward_fallback: z.boolean().default(false),
+}).transform((v) => {
+  return remap$(v, {
+    "return_type": "returnType",
+    "target_size": "targetSize",
+    "forward_fallback": "forwardFallback",
+  });
+});
+/** @internal */
+export type FastChunkerStrategy$Outbound = {
+  text: string;
+  metadata: boolean;
+  return_type: string;
+  strategy: "fast";
+  target_size: number;
+  delimiters: string;
+  pattern?: string | undefined;
+  prefix: boolean;
+  consecutive: boolean;
+  forward_fallback: boolean;
+};
+
+/** @internal */
+export const FastChunkerStrategy$outboundSchema: z.ZodType<
+  FastChunkerStrategy$Outbound,
+  z.ZodTypeDef,
+  FastChunkerStrategy
+> = z.object({
+  text: z.string(),
+  metadata: z.boolean().default(true),
+  returnType:
+    ParseChunkingRequestChunkingRequestRequestBodyReturnType$outboundSchema
+      .default("chunks"),
+  strategy: z.literal("fast"),
+  targetSize: z.number().int().default(4096),
+  delimiters: z.string().default("\n.?"),
+  pattern: z.string().optional(),
+  prefix: z.boolean().default(false),
+  consecutive: z.boolean().default(false),
+  forwardFallback: z.boolean().default(false),
+}).transform((v) => {
+  return remap$(v, {
+    returnType: "return_type",
+    targetSize: "target_size",
+    forwardFallback: "forward_fallback",
+  });
+});
+
+export function fastChunkerStrategyToJSON(
+  fastChunkerStrategy: FastChunkerStrategy,
+): string {
+  return JSON.stringify(
+    FastChunkerStrategy$outboundSchema.parse(fastChunkerStrategy),
+  );
+}
+export function fastChunkerStrategyFromJSON(
+  jsonString: string,
+): SafeParseResult<FastChunkerStrategy, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FastChunkerStrategy$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FastChunkerStrategy' from JSON`,
+  );
+}
+
 /** @internal */
 export const ParseChunkingRequestChunkingRequestReturnType$inboundSchema:
   z.ZodNativeEnum<typeof ParseChunkingRequestChunkingRequestReturnType> = z
@@ -775,6 +927,7 @@ export const ParseChunkingRequest$inboundSchema: z.ZodType<
   z.lazy(() => RecursiveChunkerStrategy$inboundSchema),
   z.lazy(() => SemanticChunkerStrategy$inboundSchema),
   z.lazy(() => AgenticChunkerStrategy$inboundSchema),
+  z.lazy(() => FastChunkerStrategy$inboundSchema),
 ]);
 /** @internal */
 export type ParseChunkingRequest$Outbound =
@@ -782,7 +935,8 @@ export type ParseChunkingRequest$Outbound =
   | SentenceChunkerStrategy$Outbound
   | RecursiveChunkerStrategy$Outbound
   | SemanticChunkerStrategy$Outbound
-  | AgenticChunkerStrategy$Outbound;
+  | AgenticChunkerStrategy$Outbound
+  | FastChunkerStrategy$Outbound;
 
 /** @internal */
 export const ParseChunkingRequest$outboundSchema: z.ZodType<
@@ -795,6 +949,7 @@ export const ParseChunkingRequest$outboundSchema: z.ZodType<
   z.lazy(() => RecursiveChunkerStrategy$outboundSchema),
   z.lazy(() => SemanticChunkerStrategy$outboundSchema),
   z.lazy(() => AgenticChunkerStrategy$outboundSchema),
+  z.lazy(() => FastChunkerStrategy$outboundSchema),
 ]);
 
 export function parseChunkingRequestToJSON(

package/src/models/operations/remoteconfigsgetconfig.ts

@@ -23,6 +23,9 @@ export type RemoteConfigsGetConfigRequestBody = {
   metadata?: { [k: string]: any } | undefined;
 };
 
+/**
+ * The return type of the rule
+ */
 export const RemoteConfigsGetConfigType = {
   Boolean: "boolean",
   String: "string",
@@ -32,6 +35,9 @@ export const RemoteConfigsGetConfigType = {
   Json: "json",
   Deployment: "deployment",
 } as const;
+/**
+ * The return type of the rule
+ */
 export type RemoteConfigsGetConfigType = ClosedEnum<
   typeof RemoteConfigsGetConfigType
 >;
@@ -40,6 +46,9 @@ export type RemoteConfigsGetConfigType = ClosedEnum<
  * An individual remote config
  */
 export type RemoteConfigsGetConfigResponseBody = {
+  /**
+   * The return type of the rule
+   */
   type: RemoteConfigsGetConfigType;
   value?: any | undefined;
 };