scorecard-ai 1.0.0-alpha.8 → 1.0.0

package/resources/systems.mjs

@@ -1,139 +1,3 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-import { APIResource } from "../core/resource.mjs";
-import { PaginatedResponse } from "../core/pagination.mjs";
-import { path } from "../internal/utils/path.mjs";
-export class Systems extends APIResource {
-    /**
-     * Create a new system definition that specifies the interface contracts for a
-     * component you want to evaluate.
-     *
-     * A system acts as a template that defines three key contracts through JSON
-     * Schemas:
-     *
-     * 1. Input Schema: What data your system accepts (e.g., user queries, context
-     *    documents)
-     * 2. Output Schema: What data your system produces (e.g., responses, confidence
-     *    scores)
-     * 3. Config Schema: What parameters can be adjusted (e.g., model selection,
-     *    temperature)
-     *
-     * This separation lets you evaluate any system as a black box, focusing on its
-     * interface rather than implementation details.
-     *
-     * @example
-     * ```ts
-     * const system = await client.systems.create('314', {
-     *   configSchema: {
-     *     type: 'object',
-     *     properties: {
-     *       temperature: { type: 'number' },
-     *       maxTokens: { type: 'integer' },
-     *       model: { type: 'string', enum: ['gpt-4', 'gpt-4-turbo'] },
-     *     },
-     *     required: ['model'],
-     *   },
-     *   description: 'Production chatbot powered by GPT-4',
-     *   inputSchema: {
-     *     type: 'object',
-     *     properties: {
-     *       messages: {
-     *         type: 'array',
-     *         items: {
-     *           type: 'object',
-     *           properties: {
-     *             role: { type: 'string', enum: ['system', 'user', 'assistant'] },
-     *             content: { type: 'string' },
-     *           },
-     *           required: ['role', 'content'],
-     *         },
-     *       },
-     *     },
-     *     required: ['messages'],
-     *   },
-     *   name: 'GPT-4 Chatbot',
-     *   outputSchema: {
-     *     type: 'object',
-     *     properties: { response: { type: 'string' } },
-     *     required: ['response'],
-     *   },
-     * });
-     * ```
-     */
-    create(projectID, body, options) {
-        return this._client.post(path `/projects/${projectID}/systems`, { body, ...options });
-    }
-    /**
-     * Update an existing system definition. Only the fields provided in the request
-     * body will be updated. If a field is provided, the new content will replace the
-     * existing content. If a field is not provided, the existing content will remain
-     * unchanged.
-     *
-     * When updating schemas:
-     *
-     * - The system will accept your changes regardless of compatibility with existing
-     *   configurations
-     * - Schema updates won't invalidate existing evaluations or configurations
-     * - For significant redesigns, creating a new system definition provides a cleaner
-     *   separation
-     *
-     * @example
-     * ```ts
-     * const system = await client.systems.update(
-     *   '12345678-0a8b-4f66-b6f3-2ddcfa097257',
-     *   {
-     *     description:
-     *       'Updated production chatbot powered by GPT-4 Turbo',
-     *     name: 'GPT-4 Turbo Chatbot',
-     *   },
-     * );
-     * ```
-     */
-    update(systemID, body = {}, options) {
-        return this._client.patch(path `/systems/${systemID}`, { body, ...options });
-    }
-    /**
-     * Retrieve a paginated list of all systems. Systems are ordered by creation date.
-     *
-     * @example
-     * ```ts
-     * // Automatically fetches more pages as needed.
-     * for await (const system of client.systems.list('314')) {
-     *   // ...
-     * }
-     * ```
-     */
-    list(projectID, query = {}, options) {
-        return this._client.getAPIList(path `/projects/${projectID}/systems`, (PaginatedResponse), {
-            query,
-            ...options,
-        });
-    }
-    /**
-     * Delete a system definition by ID. This will not delete associated system
-     * configurations.
-     *
-     * @example
-     * ```ts
-     * const system = await client.systems.delete(
-     *   '12345678-0a8b-4f66-b6f3-2ddcfa097257',
-     * );
-     * ```
-     */
-    delete(systemID, options) {
-        return this._client.delete(path `/systems/${systemID}`, options);
-    }
-    /**
-     * Retrieve a specific system by ID.
-     *
-     * @example
-     * ```ts
-     * const system = await client.systems.get(
-     *   '12345678-0a8b-4f66-b6f3-2ddcfa097257',
-     * );
-     * ```
-     */
-    get(systemID, options) {
-        return this._client.get(path `/systems/${systemID}`, options);
-    }
-}
+export * from "./systems/index.mjs";
 //# sourceMappingURL=systems.mjs.map

package/resources/systems.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"systems.mjs","sourceRoot":"","sources":["../src/resources/systems.ts"],"names":[],"mappings":"AAAA,sFAAsF;OAE/E,EAAE,WAAW,EAAE;OAEf,EAAe,iBAAiB,EAAgC;OAEhE,EAAE,IAAI,EAAE;AAEf,MAAM,OAAO,OAAQ,SAAQ,WAAW;IACtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuDG;IACH,MAAM,CAAC,SAAiB,EAAE,IAAwB,EAAE,OAAwB;QAC1E,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAA,aAAa,SAAS,UAAU,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IACvF,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,MAAM,CACJ,QAAgB,EAChB,OAA8C,EAAE,EAChD,OAAwB;QAExB,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAA,YAAY,QAAQ,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;IAC9E,CAAC;IAED;;;;;;;;;;OAUG;IACH,IAAI,CACF,SAAiB,EACjB,QAA6C,EAAE,EAC/C,OAAwB;QAExB,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAA,aAAa,SAAS,UAAU,EAAE,CAAA,iBAAyB,CAAA,EAAE;YAC9F,KAAK;YACL,GAAG,OAAO;SACX,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;OAUG;IACH,MAAM,CAAC,QAAgB,EAAE,OAAwB;QAC/C,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAA,YAAY,QAAQ,EAAE,EAAE,OAAO,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;;;;OASG;IACH,GAAG,CAAC,QAAgB,EAAE,OAAwB;QAC5C,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAA,YAAY,QAAQ,EAAE,EAAE,OAAO,CAAC,CAAC;IAC/D,CAAC;CACF"}
+{"version":3,"file":"systems.mjs","sourceRoot":"","sources":["../src/resources/systems.ts"],"names":[],"mappings":"AAAA,sFAAsF"}

package/resources/testsets.d.mts

@@ -75,7 +75,7 @@ export declare class Testsets extends APIResource {
      */
     delete(testsetID: string, options?: RequestOptions): APIPromise<TestsetDeleteResponse>;
     /**
-     * Get Testset by ID
+     * Get Testset
      *
      * @example
      * ```ts

package/resources/testsets.d.ts

@@ -75,7 +75,7 @@ export declare class Testsets extends APIResource {
      */
     delete(testsetID: string, options?: RequestOptions): APIPromise<TestsetDeleteResponse>;
     /**
-     * Get Testset by ID
+     * Get Testset
      *
      * @example
      * ```ts

package/resources/testsets.js

@@ -89,7 +89,7 @@ class Testsets extends resource_1.APIResource {
         return this._client.delete((0, path_1.path) `/testsets/${testsetID}`, options);
     }
     /**
-     * Get Testset by ID
+     * Get Testset
      *
      * @example
      * ```ts

package/resources/testsets.mjs

@@ -86,7 +86,7 @@ export class Testsets extends APIResource {
         return this._client.delete(path `/testsets/${testsetID}`, options);
     }
     /**
-     * Get Testset by ID
+     * Get Testset
      *
      * @example
      * ```ts

package/src/client.ts

@@ -22,6 +22,7 @@ import { APIPromise } from './core/api-promise';
 import { type Fetch } from './internal/builtin-types';
 import { HeadersLike, NullableHeaders, buildHeaders } from './internal/headers';
 import { FinalRequestOptions, RequestOptions } from './internal/request-options';
+import { Metric, MetricCreateParams, Metrics } from './resources/metrics';
 import {
   Project,
   ProjectCreateParams,
@@ -32,23 +33,6 @@ import {
 import { Record as RecordsAPIRecord, RecordCreateParams, Records } from './resources/records';
 import { Run, RunCreateParams, Runs } from './resources/runs';
 import { Score, ScoreUpsertParams, Scores } from './resources/scores';
-import {
-  SystemConfig,
-  SystemConfigCreateParams,
-  SystemConfigGetParams,
-  SystemConfigListParams,
-  SystemConfigs,
-  SystemConfigsPaginatedResponse,
-} from './resources/system-configs';
-import {
-  System,
-  SystemCreateParams,
-  SystemDeleteResponse,
-  SystemListParams,
-  SystemUpdateParams,
-  Systems,
-  SystemsPaginatedResponse,
-} from './resources/systems';
 import {
   Testcase,
   TestcaseCreateParams,
@@ -72,6 +56,15 @@ import {
 import { readEnv } from './internal/utils/env';
 import { formatRequestDetails, loggerFor } from './internal/utils/log';
 import { isEmptyObj } from './internal/utils/values';
+import {
+  System,
+  SystemCreateParams,
+  SystemDeleteResponse,
+  SystemListParams,
+  SystemUpdateParams,
+  Systems,
+  SystemsPaginatedResponse,
+} from './resources/systems/systems';
 
 const environments = {
   production: 'https://api2.scorecard.io/api/v2',
@@ -80,6 +73,18 @@ const environments = {
 };
 type Environment = keyof typeof environments;
 
+function baseApiUrlToBaseAppUrl(baseApiUrl: string): string {
+  if (baseApiUrl === environments.production) {
+    return 'https://app.scorecard.io';
+  } else if (baseApiUrl === environments.staging) {
+    return 'https://staging.app.getscorecard.ai';
+  } else if (baseApiUrl === environments.local) {
+    return 'http://localhost:3002';
+  } else {
+    return 'https://staging.app.getscorecard.ai';
+  }
+}
+
 export interface ClientOptions {
   /**
    * Defaults to process.env['SCORECARD_API_KEY'].
@@ -170,6 +175,7 @@ export class Scorecard {
   apiKey: string;
 
   baseURL: string;
+  baseAppURL: string;
   maxRetries: number;
   timeout: number;
   logger: Logger | undefined;
@@ -219,6 +225,7 @@ export class Scorecard {
     }
 
     this.baseURL = options.baseURL || environments[options.environment || 'production'];
+    this.baseAppURL = baseApiUrlToBaseAppUrl(this.baseURL);
     this.timeout = options.timeout ?? Scorecard.DEFAULT_TIMEOUT /* 1 minute */;
     this.logger = options.logger ?? console;
     const defaultLogLevel = 'warn';
@@ -788,19 +795,19 @@ export class Scorecard {
   testsets: API.Testsets = new API.Testsets(this);
   testcases: API.Testcases = new API.Testcases(this);
   runs: API.Runs = new API.Runs(this);
+  metrics: API.Metrics = new API.Metrics(this);
   records: API.Records = new API.Records(this);
   scores: API.Scores = new API.Scores(this);
   systems: API.Systems = new API.Systems(this);
-  systemConfigs: API.SystemConfigs = new API.SystemConfigs(this);
 }
 Scorecard.Projects = Projects;
 Scorecard.Testsets = Testsets;
 Scorecard.Testcases = Testcases;
 Scorecard.Runs = Runs;
+Scorecard.Metrics = Metrics;
 Scorecard.Records = Records;
 Scorecard.Scores = Scores;
 Scorecard.Systems = Systems;
-Scorecard.SystemConfigs = SystemConfigs;
 export declare namespace Scorecard {
   export type RequestOptions = Opts.RequestOptions;
 
@@ -842,6 +849,8 @@ export declare namespace Scorecard {
 
   export { Runs as Runs, type Run as Run, type RunCreateParams as RunCreateParams };
 
+  export { Metrics as Metrics, type Metric as Metric, type MetricCreateParams as MetricCreateParams };
+
   export {
     Records as Records,
     type RecordsAPIRecord as Record,
@@ -860,14 +869,5 @@ export declare namespace Scorecard {
     type SystemListParams as SystemListParams,
   };
 
-  export {
-    SystemConfigs as SystemConfigs,
-    type SystemConfig as SystemConfig,
-    type SystemConfigsPaginatedResponse as SystemConfigsPaginatedResponse,
-    type SystemConfigCreateParams as SystemConfigCreateParams,
-    type SystemConfigListParams as SystemConfigListParams,
-    type SystemConfigGetParams as SystemConfigGetParams,
-  };
-
   export type APIError = API.APIError;
 }

package/src/core/pagination.ts

@@ -99,7 +99,7 @@ export class PagePromise<
    *      console.log(item)
    *    }
    */
-  async *[Symbol.asyncIterator]() {
+  async *[Symbol.asyncIterator](): AsyncGenerator<Item> {
     const page = await this;
     for await (const item of page) {
       yield item;

package/src/index.ts

@@ -21,3 +21,5 @@ export {
   PermissionDeniedError,
   UnprocessableEntityError,
 } from './core/error';
+
+export { runAndEvaluate } from './lib/runAndEvaluate';

package/src/internal/detect-platform.ts

@@ -85,10 +85,10 @@ const getPlatformProperties = (): PlatformProperties => {
     return {
       'X-Stainless-Lang': 'js',
       'X-Stainless-Package-Version': VERSION,
-      'X-Stainless-OS': normalizePlatform((globalThis as any).process.platform),
-      'X-Stainless-Arch': normalizeArch((globalThis as any).process.arch),
+      'X-Stainless-OS': normalizePlatform((globalThis as any).process.platform ?? 'unknown'),
+      'X-Stainless-Arch': normalizeArch((globalThis as any).process.arch ?? 'unknown'),
       'X-Stainless-Runtime': 'node',
-      'X-Stainless-Runtime-Version': (globalThis as any).process.version,
+      'X-Stainless-Runtime-Version': (globalThis as any).process.version ?? 'unknown',
     };
   }
 

package/src/internal/shim-types.ts

@@ -0,0 +1,26 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+/**
+ * Shims for types that we can't always rely on being available globally.
+ *
+ * Note: these only exist at the type-level, there is no corresponding runtime
+ * version for any of these symbols.
+ */
+
+type NeverToAny<T> = T extends never ? any : T;
+
+/** @ts-ignore */
+type _DOMReadableStream<R = any> = globalThis.ReadableStream<R>;
+
+/** @ts-ignore */
+type _NodeReadableStream<R = any> = import('stream/web').ReadableStream<R>;
+
+type _ConditionalNodeReadableStream<R = any> =
+  typeof globalThis extends { ReadableStream: any } ? never : _NodeReadableStream<R>;
+
+type _ReadableStream<R = any> = NeverToAny<
+  | ([0] extends [1 & _DOMReadableStream<R>] ? never : _DOMReadableStream<R>)
+  | ([0] extends [1 & _ConditionalNodeReadableStream<R>] ? never : _ConditionalNodeReadableStream<R>)
+>;
+
+export type { _ReadableStream as ReadableStream };

package/src/internal/shims.ts

@@ -7,8 +7,8 @@
  * messages in cases where an environment isn't fully supported.
  */
 
-import { type Fetch } from './builtin-types';
-import { type ReadableStream } from './shim-types';
+import type { Fetch } from './builtin-types';
+import type { ReadableStream } from './shim-types';
 
 export function getDefaultFetch(): Fetch {
   if (typeof fetch !== 'undefined') {

package/src/internal/uploads.ts

@@ -138,7 +138,7 @@ export const createForm = async <T = Record<string, unknown>>(
 
 // We check for Blob not File because Bun.File doesn't inherit from File,
 // but they both inherit from Blob and have a `name` property at runtime.
-const isNamedBlob = (value: object) => value instanceof Blob && 'name' in value;
+const isNamedBlob = (value: unknown) => value instanceof Blob && 'name' in value;
 
 const isUploadable = (value: unknown) =>
   typeof value === 'object' &&

package/src/lib/runAndEvaluate.ts

@@ -1,49 +1,177 @@
 import { Scorecard } from '../client';
+import { Testcase } from '../resources';
+import { ScorecardError } from '../error';
+import { SystemVersion } from '../resources/systems';
+
+type RunAndEvaluateArgs<SystemInput extends Record<string, any>, SystemOutput extends Record<string, any>> =
+  // Project and metrics are always required
+  {
+    /**
+     * The ID of the Project to run the system on.
+     */
+    projectId: string;
+
+    /**
+     * The IDs of the Metrics to use for evaluation.
+     */
+    metricIds: Array<string>;
+  } & (
+    | // If systemVersionId is provided, the system function receives a system version
+    {
+        /**
+         * The ID of the SystemVersion to use for the run.
+         */
+        systemVersionId: string;
+
+        /**
+         * The system function to run on the Testset.
+         */
+        system: (testcaseInput: SystemInput, systemVersion: SystemVersion) => Promise<SystemOutput>;
+      }
+    // Otherwise, the system function receives only the testcase input
+    | {
+        /**
+         * The system function to run on the Testset.
+         */
+        system: (testcaseInput: SystemInput) => Promise<SystemOutput>;
+      }
+  ) &
+    // If testset is not provided, you must pass in all the testcases manually
+    (| {
+          /**
+           * The ID of the Scorecard Testset to run the system on.
+           */
+          testsetId: string;
+        }
+      | {
+          /**
+           * The list of test cases to run the system on. Can be a list of Scorecard Testcases or a list of inputs and expected outputs.
+           */
+          testcases:
+            | Array<{
+                inputs: SystemInput;
+                expected: Record<string, unknown>;
+              }>
+            | Array<Testcase>;
+        }
+    );
+
+/**
+ * Returns an async generator over the given Testset or Testcases.
+ */
+async function* testcaseIterator<SystemInput extends Record<string, any>>(
+  scorecard: Scorecard,
+  args: RunAndEvaluateArgs<SystemInput, any>,
+): AsyncGenerator<{
+  testcaseId: string | null;
+  inputs: SystemInput;
+  expected: Record<string, unknown>;
+}> {
+  if ('testsetId' in args) {
+    for await (const testcase of scorecard.testcases.list(args.testsetId)) {
+      yield {
+        testcaseId: testcase.id,
+        inputs: testcase.inputs as SystemInput,
+        expected: testcase.expected,
+      };
+    }
+  } else {
+    for (const testcase of args.testcases) {
+      yield {
+        testcaseId: 'id' in testcase ? testcase.id : null,
+        inputs: testcase.inputs as SystemInput,
+        expected: testcase.expected,
+      };
+    }
+  }
+}
 
 /**
  * Runs a system on a Testset and records the results in Scorecard.
  *
  * @param scorecard The Scorecard client
- * @param projectId The ID of the Project to run the system on.
- * @param testsetId The ID of the Testset to run the system on.
- * @param metricIds The IDs of the Metrics to use for evaluation.
- * @param system The system to run on the Testset.
+ * @param args.projectId The ID of the Project to run the system on.
+ * @param args.testsetId The optional ID of the Testset to run the system on. Either this or `args.testcases` must be provided.
+ * @param args.testcases The optional list of Testcases to run the system on. Either this or `args.testsetId` must be provided.
+ * @param args.metricIds The IDs of the Metrics to use for evaluation.
+ * @param args.systemVersionId The optional ID of the System Version to associate with the Run.
+ * @param args.system The system to run on the Testset.
+ * @param options.runInParallel Whether to call `args.system` in parallel. False (sequential) by default.
+ * @param options.trials The number of times to run the system on each Testcase. 1 by default.
  */
-export async function runAndEvaluate<SystemInput extends Object, SystemOutput extends Object>(
+export async function runAndEvaluate<
+  SystemInput extends Record<string, any>,
+  SystemOutput extends Record<string, any>,
+>(
   scorecard: Scorecard,
-  {
-    projectId,
-    testsetId,
-    metricIds,
-    system,
-  }: {
-    projectId: string;
-    testsetId: string;
-    metricIds: Array<string>;
-    system: (testcaseInput: SystemInput) => Promise<SystemOutput>;
+  args: RunAndEvaluateArgs<SystemInput, SystemOutput>,
+  options: {
+    /**
+     * Whether to call `args.system` in parallel. False (sequential) by default.
+     */
+    runInParallel?: boolean;
+    /**
+     * The number of times to run the system on each Testcase. 1 by default.
+     */
+    trials?: number;
+  } = {
+    runInParallel: false,
+    trials: 1,
   },
-): Promise<Pick<Scorecard.Runs.Run, 'id'> & { url: string }> {
-  const run = await scorecard.runs.create(projectId, {
-    testsetId,
-    metricIds,
+): Promise<{
+  /** The ID of the Run. */
+  id: string;
+  /** The URL of the Run. */
+  url: string;
+}> {
+  const runInParallel = options.runInParallel ?? false;
+  const trials = options.trials ?? 1;
+  if (!(Number.isInteger(trials) && trials >= 1)) {
+    throw new ScorecardError('trials must be a positive integer');
+  }
+
+  const hasSystemVersion = 'systemVersionId' in args;
+  const hasTestset = 'testsetId' in args;
+
+  const runPromise = scorecard.runs.create(args.projectId, {
+    testsetId: hasTestset ? args.testsetId : null,
+    metricIds: args.metricIds,
+    ...(hasSystemVersion ?
+      {
+        systemVersionId: args.systemVersionId,
+      }
+    : null),
   });
+  const systemVersion = hasSystemVersion ? await scorecard.systems.versions.get(args.systemVersionId) : null;
+  const run = await runPromise;
+
+  const recordPromises: Array<Promise<unknown>> = [];
+
+  for await (const { testcaseId, inputs, expected } of testcaseIterator(scorecard, args)) {
+    for (let i = 0; i < trials; i++) {
+      const modelResponsePromise =
+        hasSystemVersion ? args.system(inputs, systemVersion!) : args.system(inputs);
+
+      function createRecord(outputs: SystemOutput): Promise<unknown> {
+        return scorecard.records.create(run.id, {
+          inputs,
+          expected,
+          outputs,
+          ...(testcaseId != null ? { testcaseId } : null),
+        });
+      }
 
-  // Run each Testcase sequentially
-  const recordPromises: Array<Promise<any>> = [];
-  for await (const testcase of scorecard.testcases.list(run.testsetId)) {
-    const modelResponse = await system(testcase.inputs as SystemInput);
-    const promise = scorecard.records.create(run.id, {
-      testcaseId: testcase.id,
-      inputs: testcase.inputs,
-      expected: testcase.expected,
-      outputs: modelResponse as Record<string, unknown>,
-    });
-    recordPromises.push(promise);
+      if (runInParallel) {
+        recordPromises.push(modelResponsePromise.then(createRecord));
+      } else {
+        recordPromises.push(createRecord(await modelResponsePromise));
+      }
+    }
   }
   // Wait until all the Records are created
   await Promise.all(recordPromises);
 
-  const runUrl = `https://app.getscorecard.ai/projects/${projectId}/runs/grades/${run.id}`;
+  const runUrl = `${scorecard.baseAppURL}/projects/${args.projectId}/runs/${run.id}`;
 
   return { id: run.id, url: runUrl };
 }

package/src/resources/index.ts

@@ -1,6 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 export * from './shared';
+export { Metrics, type Metric, type MetricCreateParams } from './metrics';
 export {
   Projects,
   type Project,
@@ -11,14 +12,6 @@ export {
 export { Records, type Record, type RecordCreateParams } from './records';
 export { Runs, type Run, type RunCreateParams } from './runs';
 export { Scores, type Score, type ScoreUpsertParams } from './scores';
-export {
-  SystemConfigs,
-  type SystemConfig,
-  type SystemConfigCreateParams,
-  type SystemConfigListParams,
-  type SystemConfigGetParams,
-  type SystemConfigsPaginatedResponse,
-} from './system-configs';
 export {
   Systems,
   type System,
@@ -27,7 +20,7 @@ export {
   type SystemUpdateParams,
   type SystemListParams,
   type SystemsPaginatedResponse,
-} from './systems';
+} from './systems/systems';
 export {
   Testcases,
   type Testcase,