@roarkanalytics/sdk 2.20.0 → 2.21.1

package/src/internal/uploads.ts

@@ -0,0 +1,307 @@
+import { type RequestOptions } from './request-options';
+import type { FilePropertyBag, Fetch } from './builtin-types';
+import { isFsReadStreamLike, type FsReadStreamLike } from './shims';
+import type { Roark } from '../client';
+import './polyfill/file.node.js';
+
+type BlobLikePart = string | ArrayBuffer | ArrayBufferView | BlobLike | DataView;
+type BlobPart = string | ArrayBuffer | ArrayBufferView | Blob | DataView;
+
+/**
+ * Typically, this is a native "File" class.
+ *
+ * We provide the {@link toFile} utility to convert a variety of objects
+ * into the File class.
+ *
+ * For convenience, you can also pass a fetch Response, or in Node,
+ * the result of fs.createReadStream().
+ */
+export type Uploadable = FileLike | ResponseLike | FsReadStreamLike;
+
+/**
+ * Intended to match DOM Blob, node-fetch Blob, node:buffer Blob, etc.
+ * Don't add arrayBuffer here, node-fetch doesn't have it
+ */
+interface BlobLike {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/size) */
+  readonly size: number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/type) */
+  readonly type: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/text) */
+  text(): Promise<string>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/slice) */
+  slice(start?: number, end?: number): BlobLike;
+}
+
+/**
+ * This check adds the arrayBuffer() method type because it is available and used at runtime
+ */
+const isBlobLike = (value: any): value is BlobLike & { arrayBuffer(): Promise<ArrayBuffer> } =>
+  value != null &&
+  typeof value === 'object' &&
+  typeof value.size === 'number' &&
+  typeof value.type === 'string' &&
+  typeof value.text === 'function' &&
+  typeof value.slice === 'function' &&
+  typeof value.arrayBuffer === 'function';
+
+/**
+ * Intended to match DOM File, node:buffer File, undici File, etc.
+ */
+interface FileLike extends BlobLike {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/lastModified) */
+  readonly lastModified: number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/name) */
+  readonly name: string;
+}
+declare var FileClass: {
+  prototype: FileLike;
+  new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): FileLike;
+};
+
+/**
+ * This check adds the arrayBuffer() method type because it is available and used at runtime
+ */
+const isFileLike = (value: any): value is FileLike & { arrayBuffer(): Promise<ArrayBuffer> } =>
+  value != null &&
+  typeof value === 'object' &&
+  typeof value.name === 'string' &&
+  typeof value.lastModified === 'number' &&
+  isBlobLike(value);
+
+/**
+ * Intended to match DOM Response, node-fetch Response, undici Response, etc.
+ */
+export interface ResponseLike {
+  url: string;
+  blob(): Promise<BlobLike>;
+}
+
+const isResponseLike = (value: any): value is ResponseLike =>
+  value != null &&
+  typeof value === 'object' &&
+  typeof value.url === 'string' &&
+  typeof value.blob === 'function';
+
+const isUploadable = (value: any): value is Uploadable => {
+  return isFileLike(value) || isResponseLike(value) || isFsReadStreamLike(value);
+};
+
+type ToFileInput = Uploadable | Exclude<BlobLikePart, string> | AsyncIterable<BlobLikePart>;
+
+/**
+ * Construct a `File` instance. This is used to ensure a helpful error is thrown
+ * for environments that don't define a global `File` yet and so that we don't
+ * accidentally rely on a global `File` type in our annotations.
+ */
+function makeFile(fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): FileLike {
+  const File = (globalThis as any).File as typeof FileClass | undefined;
+  if (typeof File === 'undefined') {
+    throw new Error('`File` is not defined as a global which is required for file uploads');
+  }
+
+  return new File(fileBits, fileName, options);
+}
+
+/**
+ * Helper for creating a {@link File} to pass to an SDK upload method from a variety of different data formats
+ * @param value the raw content of the file.  Can be an {@link Uploadable}, {@link BlobLikePart}, or {@link AsyncIterable} of {@link BlobLikePart}s
+ * @param {string=} name the name of the file. If omitted, toFile will try to determine a file name from bits if possible
+ * @param {Object=} options additional properties
+ * @param {string=} options.type the MIME type of the content
+ * @param {number=} options.lastModified the last modified timestamp
+ * @returns a {@link File} with the given properties
+ */
+export async function toFile(
+  value: ToFileInput | PromiseLike<ToFileInput>,
+  name?: string | null | undefined,
+  options?: FilePropertyBag | undefined,
+): Promise<FileLike> {
+  // If it's a promise, resolve it.
+  value = await value;
+
+  // If we've been given a `File` we don't need to do anything
+  if (isFileLike(value)) {
+    const File = (globalThis as any).File as typeof FileClass | undefined;
+    if (File && value instanceof File) {
+      return value;
+    }
+    return makeFile([await value.arrayBuffer()], value.name);
+  }
+
+  if (isResponseLike(value)) {
+    const blob = await value.blob();
+    name ||= new URL(value.url).pathname.split(/[\\/]/).pop() ?? 'unknown_file';
+
+    return makeFile(await getBytes(blob), name, options);
+  }
+
+  const parts = await getBytes(value);
+
+  name ||= getName(value) ?? 'unknown_file';
+
+  if (!options?.type) {
+    const type = parts.find((part) => typeof part === 'object' && 'type' in part && part.type);
+    if (typeof type === 'string') {
+      options = { ...options, type };
+    }
+  }
+
+  return makeFile(parts, name, options);
+}
+
+export async function getBytes(
+  value: Uploadable | BlobLikePart | AsyncIterable<BlobLikePart>,
+): Promise<Array<BlobPart>> {
+  let parts: Array<BlobPart> = [];
+  if (
+    typeof value === 'string' ||
+    ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc.
+    value instanceof ArrayBuffer
+  ) {
+    parts.push(value);
+  } else if (isBlobLike(value)) {
+    parts.push(value instanceof Blob ? value : await value.arrayBuffer());
+  } else if (
+    isAsyncIterableIterator(value) // includes Readable, ReadableStream, etc.
+  ) {
+    for await (const chunk of value) {
+      parts.push(...(await getBytes(chunk as BlobLikePart))); // TODO, consider validating?
+    }
+  } else {
+    const constructor = value?.constructor?.name;
+    throw new Error(
+      `Unexpected data type: ${typeof value}${
+        constructor ? `; constructor: ${constructor}` : ''
+      }${propsForError(value)}`,
+    );
+  }
+
+  return parts;
+}
+
+function propsForError(value: unknown): string {
+  if (typeof value !== 'object' || value === null) return '';
+  const props = Object.getOwnPropertyNames(value);
+  return `; props: [${props.map((p) => `"${p}"`).join(', ')}]`;
+}
+
+function getName(value: unknown): string | undefined {
+  return (
+    (typeof value === 'object' &&
+      value !== null &&
+      (('name' in value && String(value.name)) ||
+        ('filename' in value && String(value.filename)) ||
+        ('path' in value && String(value.path).split(/[\\/]/).pop()))) ||
+    undefined
+  );
+}
+
+const isAsyncIterableIterator = (value: any): value is AsyncIterableIterator<unknown> =>
+  value != null && typeof value === 'object' && typeof value[Symbol.asyncIterator] === 'function';
+
+/**
+ * Returns a multipart/form-data request if any part of the given request body contains a File / Blob value.
+ * Otherwise returns the request as is.
+ */
+export const maybeMultipartFormRequestOptions = async (
+  opts: RequestOptions,
+  fetch: Roark | Fetch,
+): Promise<RequestOptions> => {
+  if (!hasUploadableValue(opts.body)) return opts;
+
+  return { ...opts, body: await createForm(opts.body, fetch) };
+};
+
+type MultipartFormRequestOptions = Omit<RequestOptions, 'body'> & { body: unknown };
+
+export const multipartFormRequestOptions = async (
+  opts: MultipartFormRequestOptions,
+  fetch: Roark | Fetch,
+): Promise<RequestOptions> => {
+  return { ...opts, body: await createForm(opts.body, fetch) };
+};
+
+const supportsFormDataMap = new WeakMap<Fetch, Promise<boolean>>();
+
+/**
+ * node-fetch doesn't support the global FormData object in recent node versions. Instead of sending
+ * properly-encoded form data, it just stringifies the object, resulting in a request body of "[object FormData]".
+ * This function detects if the fetch function provided supports the global FormData object to avoid
+ * confusing error messages later on.
+ */
+function supportsFormData(fetchObject: Roark | Fetch): Promise<boolean> {
+  const fetch: Fetch = typeof fetchObject === 'function' ? fetchObject : (fetchObject as any).fetch;
+  const cached = supportsFormDataMap.get(fetch);
+  if (cached) return cached;
+  const promise = (async () => {
+    try {
+      const FetchResponse = (
+        'Response' in fetch ?
+          fetch.Response
+        : (await fetch('data:,')).constructor) as typeof Response;
+      const data = new FormData();
+      if (data.toString() === (await new FetchResponse(data).text())) {
+        return false;
+      }
+      return true;
+    } catch {
+      // avoid false negatives
+      return true;
+    }
+  })();
+  supportsFormDataMap.set(fetch, promise);
+  return promise;
+}
+
+export const createForm = async <T = Record<string, unknown>>(
+  body: T | undefined,
+  fetch: Roark | Fetch,
+): Promise<FormData> => {
+  if (!(await supportsFormData(fetch))) {
+    throw new TypeError(
+      'The provided fetch function does not support file uploads with the current global FormData class.',
+    );
+  }
+  const form = new FormData();
+  await Promise.all(Object.entries(body || {}).map(([key, value]) => addFormValue(form, key, value)));
+  return form;
+};
+
+const hasUploadableValue = (value: unknown): boolean => {
+  if (isUploadable(value)) return true;
+  if (Array.isArray(value)) return value.some(hasUploadableValue);
+  if (value && typeof value === 'object') {
+    for (const k in value) {
+      if (hasUploadableValue((value as any)[k])) return true;
+    }
+  }
+  return false;
+};
+
+const addFormValue = async (form: FormData, key: string, value: unknown): Promise<void> => {
+  if (value === undefined) return;
+  if (value == null) {
+    throw new TypeError(
+      `Received null for "${key}"; to pass null in FormData, you must use the string 'null'`,
+    );
+  }
+
+  // TODO: make nested formats configurable
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    form.append(key, String(value));
+  } else if (isUploadable(value)) {
+    const file = await toFile(value);
+    form.append(key, file as any);
+  } else if (Array.isArray(value)) {
+    await Promise.all(value.map((entry) => addFormValue(form, key + '[]', entry)));
+  } else if (typeof value === 'object') {
+    await Promise.all(
+      Object.entries(value).map(([name, prop]) => addFormValue(form, `${key}[${name}]`, prop)),
+    );
+  } else {
+    throw new TypeError(
+      `Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${value} instead`,
+    );
+  }
+};

package/src/internal/utils/base64.ts

@@ -0,0 +1,37 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { RoarkError } from '../../error';
+
+export const toBase64 = (data: string | Uint8Array | null | undefined): string => {
+  if (!data) return '';
+
+  if (typeof data === 'string') {
+    data = new (globalThis as any).TextEncoder().encode(data);
+  }
+
+  if (typeof (globalThis as any).Buffer !== 'undefined') {
+    return (globalThis as any).Buffer.from(data).toString('base64');
+  }
+
+  if (typeof btoa !== 'undefined') {
+    return btoa(String.fromCharCode.apply(null, data as any));
+  }
+
+  throw new RoarkError('Cannot generate base64 string; Expected `Buffer` or `btoa` to be defined');
+};
+
+export const fromBase64 = (str: string): Uint8Array => {
+  if (typeof (globalThis as any).Buffer !== 'undefined') {
+    return new Uint8Array((globalThis as any).Buffer.from(str, 'base64'));
+  }
+
+  if (typeof atob !== 'undefined') {
+    return new Uint8Array(
+      atob(str)
+        .split('')
+        .map((c) => c.charCodeAt(0)),
+    );
+  }
+
+  throw new RoarkError('Cannot decode base64 string; Expected `Buffer` or `atob` to be defined');
+};

package/src/internal/utils/env.ts

@@ -0,0 +1,18 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+/**
+ * Read an environment variable.
+ *
+ * Trims beginning and trailing whitespace.
+ *
+ * Will return undefined if the environment variable doesn't exist or cannot be accessed.
+ */
+export const readEnv = (env: string): string | undefined => {
+  if (typeof (globalThis as any).process !== 'undefined') {
+    return (globalThis as any).process.env?.[env]?.trim() ?? undefined;
+  }
+  if (typeof (globalThis as any).Deno !== 'undefined') {
+    return (globalThis as any).Deno.env?.get?.(env)?.trim();
+  }
+  return undefined;
+};

package/src/internal/utils/log.ts

@@ -0,0 +1,49 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import type { LogLevel, Logger } from '../../client';
+import { type Roark } from '../../client';
+
+const levelNumbers = {
+  off: 0,
+  error: 200,
+  warn: 300,
+  info: 400,
+  debug: 500,
+};
+
+function noop() {}
+
+function logFn(logger: Logger | undefined, clientLevel: LogLevel | undefined, level: keyof Logger) {
+  if (!logger || levelNumbers[level] > levelNumbers[clientLevel!]!) {
+    return noop;
+  } else {
+    // Don't wrap logger functions, we want the stacktrace intact!
+    return logger[level].bind(logger);
+  }
+}
+
+let lastLogger: { deref(): Logger } | undefined;
+let lastLevel: LogLevel | undefined;
+let lastLevelLogger: Logger;
+
+export function logger(client: Roark): Logger {
+  let { logger, logLevel: clientLevel } = client;
+  if (lastLevel === clientLevel && (logger === lastLogger || logger === lastLogger?.deref())) {
+    return lastLevelLogger;
+  }
+  const levelLogger = {
+    error: logFn(logger, clientLevel, 'error'),
+    warn: logFn(logger, clientLevel, 'warn'),
+    info: logFn(logger, clientLevel, 'info'),
+    debug: logFn(logger, clientLevel, 'debug'),
+  };
+  const { WeakRef } = globalThis as any;
+  lastLogger =
+    logger ?
+      WeakRef ? new WeakRef(logger)
+      : { deref: () => logger }
+    : undefined;
+  lastLevel = clientLevel;
+  lastLevelLogger = levelLogger;
+  return levelLogger;
+}

package/src/internal/utils/sleep.ts

@@ -0,0 +1,3 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));

package/src/internal/utils/uuid.ts

@@ -0,0 +1,13 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { crypto } from '../polyfill/crypto.node';
+
+/**
+ * https://stackoverflow.com/a/2117523
+ */
+export function uuid4() {
+  if (crypto.randomUUID) return crypto.randomUUID();
+  return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, (c) =>
+    (+c ^ (crypto.getRandomValues(new Uint8Array(1))[0]! & (15 >> (+c / 4)))).toString(16),
+  );
+}

package/src/internal/utils/values.ts

@@ -0,0 +1,94 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { RoarkError } from '../../error';
+
+// https://url.spec.whatwg.org/#url-scheme-string
+const startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
+
+export const isAbsoluteURL = (url: string): boolean => {
+  return startsWithSchemeRegexp.test(url);
+};
+
+/** Returns an object if the given value isn't an object, otherwise returns as-is */
+export function maybeObj(x: unknown): object {
+  if (typeof x !== 'object') {
+    return {};
+  }
+
+  return x ?? {};
+}
+
+// https://stackoverflow.com/a/34491287
+export function isEmptyObj(obj: Object | null | undefined): boolean {
+  if (!obj) return true;
+  for (const _k in obj) return false;
+  return true;
+}
+
+// https://eslint.org/docs/latest/rules/no-prototype-builtins
+export function hasOwn(obj: Object, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+export function isObj(obj: unknown): obj is Record<string, unknown> {
+  return obj != null && typeof obj === 'object' && !Array.isArray(obj);
+}
+
+export const ensurePresent = <T>(value: T | null | undefined): T => {
+  if (value == null) {
+    throw new RoarkError(`Expected a value to be given but received ${value} instead.`);
+  }
+
+  return value;
+};
+
+export const validatePositiveInteger = (name: string, n: unknown): number => {
+  if (typeof n !== 'number' || !Number.isInteger(n)) {
+    throw new RoarkError(`${name} must be an integer`);
+  }
+  if (n < 0) {
+    throw new RoarkError(`${name} must be a positive integer`);
+  }
+  return n;
+};
+
+export const coerceInteger = (value: unknown): number => {
+  if (typeof value === 'number') return Math.round(value);
+  if (typeof value === 'string') return parseInt(value, 10);
+
+  throw new RoarkError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+
+export const coerceFloat = (value: unknown): number => {
+  if (typeof value === 'number') return value;
+  if (typeof value === 'string') return parseFloat(value);
+
+  throw new RoarkError(`Could not coerce ${value} (type: ${typeof value}) into a number`);
+};
+
+export const coerceBoolean = (value: unknown): boolean => {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') return value === 'true';
+  return Boolean(value);
+};
+
+export const maybeCoerceInteger = (value: unknown): number | undefined => {
+  if (value === undefined) {
+    return undefined;
+  }
+  return coerceInteger(value);
+};
+
+export const maybeCoerceFloat = (value: unknown): number | undefined => {
+  if (value === undefined) {
+    return undefined;
+  }
+  return coerceFloat(value);
+};
+
+export const maybeCoerceBoolean = (value: unknown): boolean | undefined => {
+  if (value === undefined) {
+    return undefined;
+  }
+  return coerceBoolean(value);
+};

package/src/internal/utils.ts

@@ -0,0 +1,8 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export * from './utils/values';
+export * from './utils/base64';
+export * from './utils/env';
+export * from './utils/log';
+export * from './utils/uuid';
+export * from './utils/sleep';

package/src/resource.ts

@@ -1,8 +1,8 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import type { Roark } from './index';
+import type { Roark } from './client';
 
-export abstract class APIResource {
+export class APIResource {
   protected _client: Roark;
 
   constructor(client: Roark) {

package/src/resources/call.ts

@@ -1,47 +1,39 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { APIResource } from '../resource';
-import { isRequestOptions } from '../core';
-import * as Core from '../core';
+import { APIPromise } from '../api-promise';
+import { RequestOptions } from '../internal/request-options';
 
 export class Call extends APIResource {
   /**
    * Create a new call with recording, transcript, agents, and customers
    */
-  create(body: CallCreateParams, options?: Core.RequestOptions): Core.APIPromise<CallCreateResponse> {
+  create(body: CallCreateParams, options?: RequestOptions): APIPromise<CallCreateResponse> {
     return this._client.post('/v1/call', { body, ...options });
   }
 
   /**
    * Returns a paginated list of calls for the authenticated project.
    */
-  list(query?: CallListParams, options?: Core.RequestOptions): Core.APIPromise<CallListResponse>;
-  list(options?: Core.RequestOptions): Core.APIPromise<CallListResponse>;
   list(
-    query: CallListParams | Core.RequestOptions = {},
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<CallListResponse> {
-    if (isRequestOptions(query)) {
-      return this.list({}, query);
-    }
+    query: CallListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<CallListResponse> {
     return this._client.get('/v1/call', { query, ...options });
   }
 
   /**
    * Retrieve an existing call by its unique identifier
    */
-  getById(callId: string, options?: Core.RequestOptions): Core.APIPromise<CallGetByIDResponse> {
-    return this._client.get(`/v1/call/${callId}`, options);
+  getByID(callID: string, options?: RequestOptions): APIPromise<CallGetByIDResponse> {
+    return this._client.get(`/v1/call/${callID}`, options);
   }
 
   /**
    * Fetch all evaluation run results for a specific call.
    */
-  listEvaluationRuns(
-    callId: string,
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<CallListEvaluationRunsResponse> {
-    return this._client.get(`/v1/call/${callId}/evaluation-run`, options);
+  listEvaluationRuns(callID: string, options?: RequestOptions): APIPromise<CallListEvaluationRunsResponse> {
+    return this._client.get(`/v1/call/${callID}/evaluation-run`, options);
   }
 
   /**
@@ -49,31 +41,19 @@ export class Call extends APIResource {
    * system-generated and custom metrics. Only returns successfully computed metrics.
    */
   listMetrics(
-    callId: string,
-    query?: CallListMetricsParams,
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<CallListMetricsResponse>;
-  listMetrics(callId: string, options?: Core.RequestOptions): Core.APIPromise<CallListMetricsResponse>;
-  listMetrics(
-    callId: string,
-    query: CallListMetricsParams | Core.RequestOptions = {},
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<CallListMetricsResponse> {
-    if (isRequestOptions(query)) {
-      return this.listMetrics(callId, {}, query);
-    }
-    return this._client.get(`/v1/call/${callId}/metrics`, { query, ...options });
+    callID: string,
+    query: CallListMetricsParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<CallListMetricsResponse> {
+    return this._client.get(`/v1/call/${callID}/metrics`, { query, ...options });
   }
 
   /**
    * Fetch detailed sentiment analysis results for a specific call, including
    * emotional tone, key phrases, and sentiment scores.
    */
-  listSentimentRuns(
-    callId: string,
-    options?: Core.RequestOptions,
-  ): Core.APIPromise<CallListSentimentRunsResponse> {
-    return this._client.get(`/v1/call/${callId}/sentiment-run`, options);
+  listSentimentRuns(callID: string, options?: RequestOptions): APIPromise<CallListSentimentRunsResponse> {
+    return this._client.get(`/v1/call/${callID}/sentiment-run`, options);
   }
 }
 
@@ -227,7 +207,7 @@ export namespace CallListResponse {
     /**
      * Custom properties associated with the call
      */
-    properties?: { [key: string]: unknown } | null;
+    properties?: Record<string, unknown> | null;
 
     /**
      * Pre-signed URL to the call recording (expires in 1 hour)
@@ -392,7 +372,7 @@ export namespace CallGetByIDResponse {
     /**
      * Custom properties associated with the call
      */
-    properties?: { [key: string]: unknown } | null;
+    properties?: Record<string, unknown> | null;
 
     /**
      * Pre-signed URL to the call recording (expires in 1 hour)
@@ -955,7 +935,7 @@ export interface CallCreateParams {
    * Custom properties to include with the call. These can be used for filtering and
    * will show in the call details page
    */
-  properties?: { [key: string]: unknown };
+  properties?: Record<string, unknown>;
 
   /**
    * URL of source stereo recording. Must be accessible. Can be a signed URL.
@@ -1387,12 +1367,12 @@ export namespace CallCreateParams {
     /**
      * Parameters provided to the tool during invocation
      */
-    parameters: { [key: string]: ToolInvocation.UnionMember0 | unknown };
+    parameters: Record<string, ToolInvocation.UnionMember0 | unknown>;
 
     /**
      * Result returned by the tool after execution. Can be a string or a JSON object
      */
-    result: string | { [key: string]: unknown };
+    result: string | Record<string, unknown>;
 
     /**
      * Offset in milliseconds from the start of the call when the tool was invoked