@orq-ai/node 4.10.0-rc.5 → 4.10.0-rc.50

package/src/models/operations/listidentities.ts

@@ -4,148 +4,24 @@
 
 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;
-  metrics: ListIdentitiesMetrics;
+  filterByTags?: Array<string> | undefined;
+  includeMetrics?: boolean | undefined;
 };
 
-/**
- * List of identities
- */
-export type ListIdentitiesResponseBody = {
-  object: ListIdentitiesObject;
-  data: Array<ListIdentitiesData>;
-  hasMore: boolean;
-};
-
-/** @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),
-  );
-}
-
 /** @internal */
 export type ListIdentitiesRequest$Outbound = {
-  limit: number;
+  limit?: number | undefined;
   starting_after?: string | undefined;
   ending_before?: string | undefined;
   search?: string | undefined;
-  filter_by?: QueryParamFilterBy$Outbound | undefined;
-  include_metrics: boolean | null;
+  "filter_by.tags"?: Array<string> | undefined;
+  include_metrics?: boolean | undefined;
 };
 
 /** @internal */
@@ -154,17 +30,17 @@ export const ListIdentitiesRequest$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ListIdentitiesRequest
 > = z.object({
-  limit: z.number().int().default(10),
+  limit: z.number().int().optional(),
   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)),
+  filterByTags: z.array(z.string()).optional(),
+  includeMetrics: z.boolean().optional(),
 }).transform((v) => {
   return remap$(v, {
     startingAfter: "starting_after",
     endingBefore: "ending_before",
-    filterBy: "filter_by",
+    filterByTags: "filter_by.tags",
     includeMetrics: "include_metrics",
   });
 });
@@ -176,100 +52,3 @@ export function listIdentitiesRequestToJSON(
     ListIdentitiesRequest$outboundSchema.parse(listIdentitiesRequest),
   );
 }
-
-/** @internal */
-export const ListIdentitiesObject$inboundSchema: z.ZodNativeEnum<
-  typeof ListIdentitiesObject
-> = z.nativeEnum(ListIdentitiesObject);
-
-/** @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",
-  });
-});
-
-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-05-14T12:03:57.631Z",
-  ).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",
-  });
-});
-
-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",
-  });
-});
-
-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/listmodels.ts

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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";
+
+/**
+ * Always "list".
+ */
+export const ListModelsObject = {
+  List: "list",
+} as const;
+/**
+ * Always "list".
+ */
+export type ListModelsObject = ClosedEnum<typeof ListModelsObject>;
+
+/**
+ * Models listed.
+ */
+export type ListModelsResponseBody = {
+  /**
+   * Available models.
+   */
+  data: Array<components.PublicModelEntry> | null;
+  /**
+   * Always "list".
+   */
+  object: ListModelsObject;
+};
+
+/** @internal */
+export const ListModelsObject$inboundSchema: z.ZodNativeEnum<
+  typeof ListModelsObject
+> = z.nativeEnum(ListModelsObject);
+
+/** @internal */
+export const ListModelsResponseBody$inboundSchema: z.ZodType<
+  ListModelsResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.nullable(z.array(components.PublicModelEntry$inboundSchema)),
+  object: ListModelsObject$inboundSchema,
+});
+
+export function listModelsResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<ListModelsResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListModelsResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListModelsResponseBody' from JSON`,
+  );
+}

package/src/models/operations/modelazurefoundrydeployments.ts

@@ -0,0 +1,90 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ModelAzureFoundryDeploymentsRequestBody = {
+  apiKey: string;
+  apiVersion?: string | undefined;
+  baseUrl: string;
+  provider: string;
+};
+
+/**
+ * Azure Foundry deployments listed
+ */
+export type ModelAzureFoundryDeploymentsResponseBody = {
+  deployments: Array<components.AzureFoundryDeployment> | null;
+  region: string;
+};
+
+/** @internal */
+export type ModelAzureFoundryDeploymentsRequestBody$Outbound = {
+  api_key: string;
+  api_version?: string | undefined;
+  base_url: string;
+  provider: string;
+};
+
+/** @internal */
+export const ModelAzureFoundryDeploymentsRequestBody$outboundSchema: z.ZodType<
+  ModelAzureFoundryDeploymentsRequestBody$Outbound,
+  z.ZodTypeDef,
+  ModelAzureFoundryDeploymentsRequestBody
+> = z.object({
+  apiKey: z.string(),
+  apiVersion: z.string().optional(),
+  baseUrl: z.string(),
+  provider: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    apiKey: "api_key",
+    apiVersion: "api_version",
+    baseUrl: "base_url",
+  });
+});
+
+export function modelAzureFoundryDeploymentsRequestBodyToJSON(
+  modelAzureFoundryDeploymentsRequestBody:
+    ModelAzureFoundryDeploymentsRequestBody,
+): string {
+  return JSON.stringify(
+    ModelAzureFoundryDeploymentsRequestBody$outboundSchema.parse(
+      modelAzureFoundryDeploymentsRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export const ModelAzureFoundryDeploymentsResponseBody$inboundSchema: z.ZodType<
+  ModelAzureFoundryDeploymentsResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  deployments: z.nullable(
+    z.array(components.AzureFoundryDeployment$inboundSchema),
+  ),
+  region: z.string(),
+});
+
+export function modelAzureFoundryDeploymentsResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ModelAzureFoundryDeploymentsResponseBody,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ModelAzureFoundryDeploymentsResponseBody$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ModelAzureFoundryDeploymentsResponseBody' from JSON`,
+  );
+}

package/src/models/operations/modelcreate.ts

@@ -0,0 +1,184 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type ModelCreateRequestBody = {
+  configuration: { [k: string]: any };
+  displayName: string;
+  hasFunctions: boolean;
+  id: string;
+  inputCost: number;
+  metadata: components.ModelMetadata;
+  modelDeveloper: string;
+  modelFamily: string;
+  modelId: string;
+  modelType: string;
+  outputCost: number;
+  parameters: Array<components.CreateModelParameter> | null;
+  provider: string;
+};
+
+/**
+ * Model created successfully
+ */
+export type ModelCreateResponseBody = {
+  configuration: components.ModelConfigurationResponse;
+  created: Date;
+  description: string | null;
+  displayName: string;
+  docsUrl: string | null;
+  enabled: boolean;
+  enabledForEndpoints: boolean;
+  enabledForPlayground: boolean;
+  hasCpuPricing: boolean;
+  hasFunctions: boolean;
+  id: string;
+  inputCost: number | null;
+  inputCurrency: string;
+  isActive: boolean;
+  metadata: components.ModelMetadata;
+  modelDeveloper?: string | undefined;
+  modelFamily?: string | undefined;
+  modelId: string;
+  modelType: string;
+  outputCost: number | null;
+  outputCurrency: string;
+  owner: string;
+  parameters: Array<components.ModelParameterDocument> | null;
+  pricingUrl: string | null;
+  provider: string;
+  refId: string;
+  updated: Date;
+};
+
+/** @internal */
+export type ModelCreateRequestBody$Outbound = {
+  configuration: { [k: string]: any };
+  display_name: string;
+  has_functions: boolean;
+  id: string;
+  input_cost: number;
+  metadata: components.ModelMetadata$Outbound;
+  model_developer: string;
+  model_family: string;
+  model_id: string;
+  model_type: string;
+  output_cost: number;
+  parameters: Array<components.CreateModelParameter$Outbound> | null;
+  provider: string;
+};
+
+/** @internal */
+export const ModelCreateRequestBody$outboundSchema: z.ZodType<
+  ModelCreateRequestBody$Outbound,
+  z.ZodTypeDef,
+  ModelCreateRequestBody
+> = z.object({
+  configuration: z.record(z.any()),
+  displayName: z.string(),
+  hasFunctions: z.boolean(),
+  id: z.string(),
+  inputCost: z.number(),
+  metadata: components.ModelMetadata$outboundSchema,
+  modelDeveloper: z.string(),
+  modelFamily: z.string(),
+  modelId: z.string(),
+  modelType: z.string(),
+  outputCost: z.number(),
+  parameters: z.nullable(
+    z.array(components.CreateModelParameter$outboundSchema),
+  ),
+  provider: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    displayName: "display_name",
+    hasFunctions: "has_functions",
+    inputCost: "input_cost",
+    modelDeveloper: "model_developer",
+    modelFamily: "model_family",
+    modelId: "model_id",
+    modelType: "model_type",
+    outputCost: "output_cost",
+  });
+});
+
+export function modelCreateRequestBodyToJSON(
+  modelCreateRequestBody: ModelCreateRequestBody,
+): string {
+  return JSON.stringify(
+    ModelCreateRequestBody$outboundSchema.parse(modelCreateRequestBody),
+  );
+}
+
+/** @internal */
+export const ModelCreateResponseBody$inboundSchema: z.ZodType<
+  ModelCreateResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  configuration: components.ModelConfigurationResponse$inboundSchema,
+  created: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  description: z.nullable(z.string()),
+  display_name: z.string(),
+  docs_url: z.nullable(z.string()),
+  enabled: z.boolean(),
+  enabled_for_endpoints: z.boolean(),
+  enabled_for_playground: z.boolean(),
+  has_cpu_pricing: z.boolean(),
+  has_functions: z.boolean(),
+  id: z.string(),
+  input_cost: z.nullable(z.number()),
+  input_currency: z.string(),
+  is_active: z.boolean(),
+  metadata: components.ModelMetadata$inboundSchema,
+  model_developer: z.string().optional(),
+  model_family: z.string().optional(),
+  model_id: z.string(),
+  model_type: z.string(),
+  output_cost: z.nullable(z.number()),
+  output_currency: z.string(),
+  owner: z.string(),
+  parameters: z.nullable(
+    z.array(components.ModelParameterDocument$inboundSchema),
+  ),
+  pricing_url: z.nullable(z.string()),
+  provider: z.string(),
+  refId: z.string(),
+  updated: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+}).transform((v) => {
+  return remap$(v, {
+    "display_name": "displayName",
+    "docs_url": "docsUrl",
+    "enabled_for_endpoints": "enabledForEndpoints",
+    "enabled_for_playground": "enabledForPlayground",
+    "has_cpu_pricing": "hasCpuPricing",
+    "has_functions": "hasFunctions",
+    "input_cost": "inputCost",
+    "input_currency": "inputCurrency",
+    "is_active": "isActive",
+    "model_developer": "modelDeveloper",
+    "model_family": "modelFamily",
+    "model_id": "modelId",
+    "model_type": "modelType",
+    "output_cost": "outputCost",
+    "output_currency": "outputCurrency",
+    "pricing_url": "pricingUrl",
+  });
+});
+
+export function modelCreateResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<ModelCreateResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ModelCreateResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ModelCreateResponseBody' from JSON`,
+  );
+}