@rivetkit/engine-api-full 25.7.2 → 25.8.0

package/dist/browser/cjs/index.js

@@ -581,31 +581,45 @@ module.exports = __toCommonJS(src_exports);
 var api_exports = {};
 __export(api_exports, {
   CrashPolicy: () => CrashPolicy,
+  HealthStatus: () => HealthStatus,
+  RunnerConfigVariant: () => RunnerConfigVariant,
   datacenters: () => datacenters_exports,
+  health: () => health_exports,
   namespaces: () => namespaces_exports,
-  runnerConfigs: () => runnerConfigs_exports,
   runners: () => runners_exports
 });
 
-// src/api/resources/runnerConfigs/index.ts
-var runnerConfigs_exports = {};
+// src/api/types/CrashPolicy.ts
+var CrashPolicy = {
+  Restart: "restart",
+  Sleep: "sleep",
+  Destroy: "destroy"
+};
+
+// src/api/types/HealthStatus.ts
+var HealthStatus = {
+  Ok: "ok",
+  Error: "error"
+};
+
+// src/api/types/RunnerConfigVariant.ts
+var RunnerConfigVariant = {
+  Serverless: "serverless",
+  Normal: "normal"
+};
 
 // src/api/resources/datacenters/index.ts
 var datacenters_exports = {};
 
+// src/api/resources/health/index.ts
+var health_exports = {};
+
 // src/api/resources/namespaces/index.ts
 var namespaces_exports = {};
 
 // src/api/resources/runners/index.ts
 var runners_exports = {};
 
-// src/api/types/CrashPolicy.ts
-var CrashPolicy = {
-  Restart: "restart",
-  Sleep: "sleep",
-  Destroy: "destroy"
-};
-
 // src/core/json.ts
 var toJson = (value, replacer, space) => {
   return JSON.stringify(value, replacer, space);
@@ -2335,7 +2349,11 @@ __export(serialization_exports, {
   ActorsListResponse: () => ActorsListResponse,
   CrashPolicy: () => CrashPolicy2,
   Datacenter: () => Datacenter,
+  DatacenterHealth: () => DatacenterHealth,
   DatacentersListResponse: () => DatacentersListResponse,
+  HealthFanoutResponse: () => HealthFanoutResponse,
+  HealthResponse: () => HealthResponse,
+  HealthStatus: () => HealthStatus2,
   Namespace: () => Namespace,
   NamespaceListResponse: () => NamespaceListResponse,
   NamespacesCreateRequest: () => NamespacesCreateRequest,
@@ -2344,52 +2362,38 @@ __export(serialization_exports, {
   RivetId: () => RivetId,
   Runner: () => Runner,
   RunnerConfig: () => RunnerConfig,
+  RunnerConfigKind: () => RunnerConfigKind,
+  RunnerConfigKindNormal: () => RunnerConfigKindNormal,
+  RunnerConfigKindServerless: () => RunnerConfigKindServerless,
+  RunnerConfigKindServerlessServerless: () => RunnerConfigKindServerlessServerless,
   RunnerConfigServerless: () => RunnerConfigServerless,
-  RunnerConfigVariant: () => RunnerConfigVariant,
+  RunnerConfigVariant: () => RunnerConfigVariant2,
   RunnerConfigsDeleteResponse: () => RunnerConfigsDeleteResponse,
   RunnerConfigsListResponse: () => RunnerConfigsListResponse,
-  RunnerConfigsUpsertRequest: () => RunnerConfigsUpsertRequest,
-  RunnerConfigsUpsertRequestServerless: () => RunnerConfigsUpsertRequestServerless,
+  RunnerConfigsListResponseRunnerConfigsValue: () => RunnerConfigsListResponseRunnerConfigsValue,
+  RunnerConfigsRefreshMetadataRequestBody: () => RunnerConfigsRefreshMetadataRequestBody,
+  RunnerConfigsRefreshMetadataResponse: () => RunnerConfigsRefreshMetadataResponse,
+  RunnerConfigsServerlessHealthCheckRequest: () => RunnerConfigsServerlessHealthCheckRequest,
+  RunnerConfigsServerlessHealthCheckResponse: () => RunnerConfigsServerlessHealthCheckResponse,
+  RunnerConfigsServerlessHealthCheckResponseFailure: () => RunnerConfigsServerlessHealthCheckResponseFailure,
+  RunnerConfigsServerlessHealthCheckResponseFailureFailure: () => RunnerConfigsServerlessHealthCheckResponseFailureFailure,
+  RunnerConfigsServerlessHealthCheckResponseSuccess: () => RunnerConfigsServerlessHealthCheckResponseSuccess,
+  RunnerConfigsServerlessHealthCheckResponseSuccessSuccess: () => RunnerConfigsServerlessHealthCheckResponseSuccessSuccess,
+  RunnerConfigsServerlessMetadataError: () => RunnerConfigsServerlessMetadataError,
+  RunnerConfigsServerlessMetadataErrorInvalidRequest: () => RunnerConfigsServerlessMetadataErrorInvalidRequest,
+  RunnerConfigsServerlessMetadataErrorInvalidResponseJson: () => RunnerConfigsServerlessMetadataErrorInvalidResponseJson,
+  RunnerConfigsServerlessMetadataErrorInvalidResponseJsonInvalidResponseJson: () => RunnerConfigsServerlessMetadataErrorInvalidResponseJsonInvalidResponseJson,
+  RunnerConfigsServerlessMetadataErrorInvalidResponseSchema: () => RunnerConfigsServerlessMetadataErrorInvalidResponseSchema,
+  RunnerConfigsServerlessMetadataErrorInvalidResponseSchemaInvalidResponseSchema: () => RunnerConfigsServerlessMetadataErrorInvalidResponseSchemaInvalidResponseSchema,
+  RunnerConfigsServerlessMetadataErrorNonSuccessStatus: () => RunnerConfigsServerlessMetadataErrorNonSuccessStatus,
+  RunnerConfigsServerlessMetadataErrorNonSuccessStatusNonSuccessStatus: () => RunnerConfigsServerlessMetadataErrorNonSuccessStatusNonSuccessStatus,
+  RunnerConfigsServerlessMetadataErrorRequestFailed: () => RunnerConfigsServerlessMetadataErrorRequestFailed,
+  RunnerConfigsServerlessMetadataErrorRequestTimedOut: () => RunnerConfigsServerlessMetadataErrorRequestTimedOut,
+  RunnerConfigsUpsertRequestBody: () => RunnerConfigsUpsertRequestBody,
   RunnerConfigsUpsertResponse: () => RunnerConfigsUpsertResponse,
   RunnersListNamesResponse: () => RunnersListNamesResponse,
   RunnersListResponse: () => RunnersListResponse,
-  namespaces: () => namespaces_exports2,
-  runnerConfigs: () => runnerConfigs_exports2
-});
-
-// src/serialization/resources/runnerConfigs/index.ts
-var runnerConfigs_exports2 = {};
-__export(runnerConfigs_exports2, {
-  RunnerConfigsUpsertRequest: () => RunnerConfigsUpsertRequest,
-  RunnerConfigsUpsertRequestServerless: () => RunnerConfigsUpsertRequestServerless
-});
-
-// src/serialization/resources/runnerConfigs/types/RunnerConfigsUpsertRequestServerless.ts
-var RunnerConfigsUpsertRequestServerless = schemas_exports.object({
-  headers: schemas_exports.record(schemas_exports.string(), schemas_exports.string()),
-  maxRunners: schemas_exports.property("max_runners", schemas_exports.number()),
-  minRunners: schemas_exports.property("min_runners", schemas_exports.number()),
-  requestLifespan: schemas_exports.property("request_lifespan", schemas_exports.number()),
-  runnersMargin: schemas_exports.property("runners_margin", schemas_exports.number()),
-  slotsPerRunner: schemas_exports.property("slots_per_runner", schemas_exports.number()),
-  url: schemas_exports.string()
-});
-
-// src/serialization/resources/runnerConfigs/client/requests/RunnerConfigsUpsertRequest.ts
-var RunnerConfigsUpsertRequest = schemas_exports.object({
-  serverless: RunnerConfigsUpsertRequestServerless
-});
-
-// src/serialization/resources/namespaces/index.ts
-var namespaces_exports2 = {};
-__export(namespaces_exports2, {
-  NamespacesCreateRequest: () => NamespacesCreateRequest
-});
-
-// src/serialization/resources/namespaces/client/requests/NamespacesCreateRequest.ts
-var NamespacesCreateRequest = schemas_exports.object({
-  displayName: schemas_exports.property("display_name", schemas_exports.string()),
-  name: schemas_exports.string()
+  namespaces: () => namespaces_exports2
 });
 
 // src/serialization/types/RivetId.ts
@@ -2453,8 +2457,29 @@ var ActorsListResponse = schemas_exports.object({
 
 // src/serialization/types/Datacenter.ts
 var Datacenter = schemas_exports.object({
+  label: schemas_exports.number(),
+  name: schemas_exports.string(),
+  url: schemas_exports.string()
+});
+
+// src/serialization/types/HealthResponse.ts
+var HealthResponse = schemas_exports.object({
+  runtime: schemas_exports.string(),
+  status: schemas_exports.string(),
+  version: schemas_exports.string()
+});
+
+// src/serialization/types/HealthStatus.ts
+var HealthStatus2 = schemas_exports.enum_(["ok", "error"]);
+
+// src/serialization/types/DatacenterHealth.ts
+var DatacenterHealth = schemas_exports.object({
   datacenterLabel: schemas_exports.property("datacenter_label", schemas_exports.number()),
-  name: schemas_exports.string()
+  datacenterName: schemas_exports.property("datacenter_name", schemas_exports.string()),
+  error: schemas_exports.string().optional(),
+  response: HealthResponse.optional(),
+  rttMs: schemas_exports.property("rtt_ms", schemas_exports.number().optional()),
+  status: HealthStatus2
 });
 
 // src/serialization/types/DatacentersListResponse.ts
@@ -2463,6 +2488,11 @@ var DatacentersListResponse = schemas_exports.object({
   pagination: Pagination
 });
 
+// src/serialization/types/HealthFanoutResponse.ts
+var HealthFanoutResponse = schemas_exports.object({
+  datacenters: schemas_exports.list(DatacenterHealth)
+});
+
 // src/serialization/types/Namespace.ts
 var Namespace = schemas_exports.object({
   createTs: schemas_exports.property("create_ts", schemas_exports.number()),
@@ -2503,35 +2533,173 @@ var Runner = schemas_exports.object({
 
 // src/serialization/types/RunnerConfigServerless.ts
 var RunnerConfigServerless = schemas_exports.object({
-  headers: schemas_exports.record(schemas_exports.string(), schemas_exports.string()),
+  headers: schemas_exports.record(schemas_exports.string(), schemas_exports.string()).optional(),
   maxRunners: schemas_exports.property("max_runners", schemas_exports.number()),
-  minRunners: schemas_exports.property("min_runners", schemas_exports.number()),
+  minRunners: schemas_exports.property("min_runners", schemas_exports.number().optional()),
   requestLifespan: schemas_exports.property("request_lifespan", schemas_exports.number()),
-  runnersMargin: schemas_exports.property("runners_margin", schemas_exports.number()),
+  runnersMargin: schemas_exports.property("runners_margin", schemas_exports.number().optional()),
   slotsPerRunner: schemas_exports.property("slots_per_runner", schemas_exports.number()),
   url: schemas_exports.string()
 });
 
 // src/serialization/types/RunnerConfig.ts
 var RunnerConfig = schemas_exports.object({
-  serverless: RunnerConfigServerless
+  normal: schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional(),
+  serverless: RunnerConfigServerless.optional(),
+  metadata: schemas_exports.unknown().optional()
+});
+
+// src/serialization/types/RunnerConfigKindNormal.ts
+var RunnerConfigKindNormal = schemas_exports.object({
+  normal: schemas_exports.record(schemas_exports.string(), schemas_exports.unknown())
+});
+
+// src/serialization/types/RunnerConfigKindServerlessServerless.ts
+var RunnerConfigKindServerlessServerless = schemas_exports.object({
+  headers: schemas_exports.record(schemas_exports.string(), schemas_exports.string()).optional(),
+  maxRunners: schemas_exports.property("max_runners", schemas_exports.number()),
+  minRunners: schemas_exports.property("min_runners", schemas_exports.number().optional()),
+  requestLifespan: schemas_exports.property("request_lifespan", schemas_exports.number()),
+  runnersMargin: schemas_exports.property("runners_margin", schemas_exports.number().optional()),
+  slotsPerRunner: schemas_exports.property("slots_per_runner", schemas_exports.number()),
+  url: schemas_exports.string()
 });
 
+// src/serialization/types/RunnerConfigKindServerless.ts
+var RunnerConfigKindServerless = schemas_exports.object({
+  serverless: RunnerConfigKindServerlessServerless
+});
+
+// src/serialization/types/RunnerConfigKind.ts
+var RunnerConfigKind = schemas_exports.undiscriminatedUnion([RunnerConfigKindNormal, RunnerConfigKindServerless]);
+
 // src/serialization/types/RunnerConfigVariant.ts
-var RunnerConfigVariant = schemas_exports.stringLiteral("serverless");
+var RunnerConfigVariant2 = schemas_exports.enum_(["serverless", "normal"]);
 
 // src/serialization/types/RunnerConfigsDeleteResponse.ts
 var RunnerConfigsDeleteResponse = schemas_exports.record(schemas_exports.string(), schemas_exports.unknown());
 
+// src/serialization/types/RunnerConfigsListResponseRunnerConfigsValue.ts
+var RunnerConfigsListResponseRunnerConfigsValue = schemas_exports.object({
+  datacenters: schemas_exports.record(schemas_exports.string(), RunnerConfig)
+});
+
 // src/serialization/types/RunnerConfigsListResponse.ts
 var RunnerConfigsListResponse = schemas_exports.object({
   pagination: Pagination,
   runnerConfigs: schemas_exports.property(
     "runner_configs",
-    schemas_exports.record(schemas_exports.string(), RunnerConfig)
+    schemas_exports.record(schemas_exports.string(), RunnerConfigsListResponseRunnerConfigsValue)
+  )
+});
+
+// src/serialization/types/RunnerConfigsRefreshMetadataRequestBody.ts
+var RunnerConfigsRefreshMetadataRequestBody = schemas_exports.record(schemas_exports.string(), schemas_exports.unknown());
+
+// src/serialization/types/RunnerConfigsRefreshMetadataResponse.ts
+var RunnerConfigsRefreshMetadataResponse = schemas_exports.record(schemas_exports.string(), schemas_exports.unknown());
+
+// src/serialization/types/RunnerConfigsServerlessHealthCheckResponseSuccessSuccess.ts
+var RunnerConfigsServerlessHealthCheckResponseSuccessSuccess = schemas_exports.object({
+  version: schemas_exports.string()
+});
+
+// src/serialization/types/RunnerConfigsServerlessHealthCheckResponseSuccess.ts
+var RunnerConfigsServerlessHealthCheckResponseSuccess = schemas_exports.object({
+  success: RunnerConfigsServerlessHealthCheckResponseSuccessSuccess
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorInvalidRequest.ts
+var RunnerConfigsServerlessMetadataErrorInvalidRequest = schemas_exports.object({
+  invalidRequest: schemas_exports.property(
+    "invalid_request",
+    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown())
+  )
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorRequestFailed.ts
+var RunnerConfigsServerlessMetadataErrorRequestFailed = schemas_exports.object({
+  requestFailed: schemas_exports.property(
+    "request_failed",
+    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown())
+  )
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorRequestTimedOut.ts
+var RunnerConfigsServerlessMetadataErrorRequestTimedOut = schemas_exports.object({
+  requestTimedOut: schemas_exports.property(
+    "request_timed_out",
+    schemas_exports.record(schemas_exports.string(), schemas_exports.unknown())
   )
 });
 
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorNonSuccessStatusNonSuccessStatus.ts
+var RunnerConfigsServerlessMetadataErrorNonSuccessStatusNonSuccessStatus = schemas_exports.object({
+  body: schemas_exports.string(),
+  statusCode: schemas_exports.property("status_code", schemas_exports.number())
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorNonSuccessStatus.ts
+var RunnerConfigsServerlessMetadataErrorNonSuccessStatus = schemas_exports.object({
+  nonSuccessStatus: schemas_exports.property(
+    "non_success_status",
+    RunnerConfigsServerlessMetadataErrorNonSuccessStatusNonSuccessStatus
+  )
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorInvalidResponseJsonInvalidResponseJson.ts
+var RunnerConfigsServerlessMetadataErrorInvalidResponseJsonInvalidResponseJson = schemas_exports.object({
+  body: schemas_exports.string()
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorInvalidResponseJson.ts
+var RunnerConfigsServerlessMetadataErrorInvalidResponseJson = schemas_exports.object({
+  invalidResponseJson: schemas_exports.property(
+    "invalid_response_json",
+    RunnerConfigsServerlessMetadataErrorInvalidResponseJsonInvalidResponseJson
+  )
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorInvalidResponseSchemaInvalidResponseSchema.ts
+var RunnerConfigsServerlessMetadataErrorInvalidResponseSchemaInvalidResponseSchema = schemas_exports.object({
+  runtime: schemas_exports.string(),
+  version: schemas_exports.string()
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataErrorInvalidResponseSchema.ts
+var RunnerConfigsServerlessMetadataErrorInvalidResponseSchema = schemas_exports.object({
+  invalidResponseSchema: schemas_exports.property(
+    "invalid_response_schema",
+    RunnerConfigsServerlessMetadataErrorInvalidResponseSchemaInvalidResponseSchema
+  )
+});
+
+// src/serialization/types/RunnerConfigsServerlessMetadataError.ts
+var RunnerConfigsServerlessMetadataError = schemas_exports.undiscriminatedUnion([
+  RunnerConfigsServerlessMetadataErrorInvalidRequest,
+  RunnerConfigsServerlessMetadataErrorRequestFailed,
+  RunnerConfigsServerlessMetadataErrorRequestTimedOut,
+  RunnerConfigsServerlessMetadataErrorNonSuccessStatus,
+  RunnerConfigsServerlessMetadataErrorInvalidResponseJson,
+  RunnerConfigsServerlessMetadataErrorInvalidResponseSchema
+]);
+
+// src/serialization/types/RunnerConfigsServerlessHealthCheckResponseFailureFailure.ts
+var RunnerConfigsServerlessHealthCheckResponseFailureFailure = schemas_exports.object({
+  error: RunnerConfigsServerlessMetadataError
+});
+
+// src/serialization/types/RunnerConfigsServerlessHealthCheckResponseFailure.ts
+var RunnerConfigsServerlessHealthCheckResponseFailure = schemas_exports.object({
+  failure: RunnerConfigsServerlessHealthCheckResponseFailureFailure
+});
+
+// src/serialization/types/RunnerConfigsServerlessHealthCheckResponse.ts
+var RunnerConfigsServerlessHealthCheckResponse = schemas_exports.undiscriminatedUnion([
+  RunnerConfigsServerlessHealthCheckResponseSuccess,
+  RunnerConfigsServerlessHealthCheckResponseFailure
+]);
+
 // src/serialization/types/RunnerConfigsUpsertResponse.ts
 var RunnerConfigsUpsertResponse = schemas_exports.record(schemas_exports.string(), schemas_exports.unknown());
 
@@ -2550,6 +2718,7 @@ var RunnersListResponse = schemas_exports.object({
 // src/serialization/client/requests/ActorsCreateRequest.ts
 var ActorsCreateRequest = schemas_exports.object({
   crashPolicy: schemas_exports.property("crash_policy", CrashPolicy2),
+  datacenter: schemas_exports.string().optional(),
   input: schemas_exports.string().optional(),
   key: schemas_exports.string().optional(),
   name: schemas_exports.string(),
@@ -2559,12 +2728,36 @@ var ActorsCreateRequest = schemas_exports.object({
 // src/serialization/client/requests/ActorsGetOrCreateRequest.ts
 var ActorsGetOrCreateRequest = schemas_exports.object({
   crashPolicy: schemas_exports.property("crash_policy", CrashPolicy2),
+  datacenter: schemas_exports.string().optional(),
   input: schemas_exports.string().optional(),
   key: schemas_exports.string(),
   name: schemas_exports.string(),
   runnerNameSelector: schemas_exports.property("runner_name_selector", schemas_exports.string())
 });
 
+// src/serialization/client/requests/RunnerConfigsServerlessHealthCheckRequest.ts
+var RunnerConfigsServerlessHealthCheckRequest = schemas_exports.object({
+  headers: schemas_exports.record(schemas_exports.string(), schemas_exports.string()).optional(),
+  url: schemas_exports.string()
+});
+
+// src/serialization/client/requests/RunnerConfigsUpsertRequestBody.ts
+var RunnerConfigsUpsertRequestBody = schemas_exports.object({
+  datacenters: schemas_exports.record(schemas_exports.string(), RunnerConfig)
+});
+
+// src/serialization/resources/namespaces/index.ts
+var namespaces_exports2 = {};
+__export(namespaces_exports2, {
+  NamespacesCreateRequest: () => NamespacesCreateRequest
+});
+
+// src/serialization/resources/namespaces/client/requests/NamespacesCreateRequest.ts
+var NamespacesCreateRequest = schemas_exports.object({
+  displayName: schemas_exports.property("display_name", schemas_exports.string()),
+  name: schemas_exports.string()
+});
+
 // src/errors/RivetError.ts
 var RivetError = class _RivetError extends Error {
   statusCode;
@@ -2672,8 +2865,74 @@ var Datacenters = class {
   }
 };
 
-// src/api/resources/namespaces/client/Client.ts
+// src/api/resources/health/client/Client.ts
 var import_url_join2 = __toESM(require("url-join"));
+var Health = class {
+  constructor(_options) {
+    this._options = _options;
+  }
+  /**
+   * @param {Health.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.health.fanout()
+   */
+  async fanout(requestOptions) {
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join2.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "health/fanout"
+      ),
+      method: "GET",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      requestType: "json",
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return HealthFanoutResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling GET /health/fanout.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  async _getAuthorizationHeader() {
+    return `Bearer ${await Supplier.get(this._options.token)}`;
+  }
+};
+
+// src/api/resources/namespaces/client/Client.ts
+var import_url_join3 = __toESM(require("url-join"));
 var Namespaces = class {
   constructor(_options) {
     this._options = _options;
@@ -2701,7 +2960,7 @@ var Namespaces = class {
       _queryParams["namespace_ids"] = namespaceIds;
     }
     const _response = await (this._options.fetcher ?? fetcher)({
-      url: (0, import_url_join2.default)(
+      url: (0, import_url_join3.default)(
         await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
         "namespaces"
       ),
@@ -2761,7 +3020,7 @@ var Namespaces = class {
    */
   async create(request, requestOptions) {
     const _response = await (this._options.fetcher ?? fetcher)({
-      url: (0, import_url_join2.default)(
+      url: (0, import_url_join3.default)(
         await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
         "namespaces"
       ),
@@ -2814,43 +3073,44 @@ var Namespaces = class {
   }
 };
 
-// src/api/resources/runnerConfigs/client/Client.ts
-var import_url_join3 = __toESM(require("url-join"));
-var RunnerConfigs = class {
+// src/api/resources/runners/client/Client.ts
+var import_url_join4 = __toESM(require("url-join"));
+var Runners = class {
   constructor(_options) {
     this._options = _options;
   }
   /**
-   * @param {Rivet.RunnerConfigsListRequest} request
-   * @param {RunnerConfigs.RequestOptions} requestOptions - Request-specific configuration.
+   * @param {Rivet.RunnersListRequest} request
+   * @param {Runners.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @example
-   *     await client.runnerConfigs.list({
+   *     await client.runners.list({
    *         namespace: "namespace"
    *     })
    */
   async list(request, requestOptions) {
-    const { namespace, limit, cursor, variant, runnerNames } = request;
+    const { namespace, name, runnerIds, includeStopped, limit, cursor } = request;
     const _queryParams = {};
     _queryParams["namespace"] = namespace;
+    if (name != null) {
+      _queryParams["name"] = name;
+    }
+    if (runnerIds != null) {
+      _queryParams["runner_ids"] = runnerIds;
+    }
+    if (includeStopped != null) {
+      _queryParams["include_stopped"] = includeStopped.toString();
+    }
     if (limit != null) {
       _queryParams["limit"] = limit.toString();
     }
     if (cursor != null) {
       _queryParams["cursor"] = cursor;
     }
-    if (variant != null) {
-      _queryParams["variant"] = RunnerConfigVariant.jsonOrThrow(variant, {
-        unrecognizedObjectKeys: "strip"
-      });
-    }
-    if (runnerNames != null) {
-      _queryParams["runner_names"] = runnerNames;
-    }
     const _response = await (this._options.fetcher ?? fetcher)({
-      url: (0, import_url_join3.default)(
+      url: (0, import_url_join4.default)(
         await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
-        "runner-configs"
+        "runners"
       ),
       method: "GET",
       headers: {
@@ -2868,7 +3128,7 @@ var RunnerConfigs = class {
       abortSignal: requestOptions?.abortSignal
     });
     if (_response.ok) {
-      return RunnerConfigsListResponse.parseOrThrow(_response.body, {
+      return RunnersListResponse.parseOrThrow(_response.body, {
         unrecognizedObjectKeys: "passthrough",
         allowUnrecognizedUnionMembers: true,
         allowUnrecognizedEnumValues: true,
@@ -2889,7 +3149,7 @@ var RunnerConfigs = class {
           body: _response.error.rawBody
         });
       case "timeout":
-        throw new RivetTimeoutError("Timeout exceeded when calling GET /runner-configs.");
+        throw new RivetTimeoutError("Timeout exceeded when calling GET /runners.");
       case "unknown":
         throw new RivetError({
           message: _response.error.errorMessage
@@ -2897,36 +3157,35 @@ var RunnerConfigs = class {
     }
   }
   /**
-   * @param {string} runnerName
-   * @param {Rivet.RunnerConfigsUpsertRequest} request
-   * @param {RunnerConfigs.RequestOptions} requestOptions - Request-specific configuration.
+   * 2 round trips:
+   *
+   * - GET /runners/names (fanout)
+   * - [api-peer] namespace::ops::resolve_for_name_global
+   *
+   * @param {Rivet.RunnersListNamesRequest} request
+   * @param {Runners.RequestOptions} requestOptions - Request-specific configuration.
    *
    * @example
-   *     await client.runnerConfigs.upsert("runner_name", {
-   *         namespace: "namespace",
-   *         serverless: {
-   *             headers: {
-   *                 "key": "value"
-   *             },
-   *             maxRunners: 1,
-   *             minRunners: 1,
-   *             requestLifespan: 1,
-   *             runnersMargin: 1,
-   *             slotsPerRunner: 1,
-   *             url: "url"
-   *         }
+   *     await client.runners.listNames({
+   *         namespace: "namespace"
    *     })
    */
-  async upsert(runnerName, request, requestOptions) {
-    const { namespace, ..._body } = request;
+  async listNames(request, requestOptions) {
+    const { namespace, limit, cursor } = request;
     const _queryParams = {};
     _queryParams["namespace"] = namespace;
+    if (limit != null) {
+      _queryParams["limit"] = limit.toString();
+    }
+    if (cursor != null) {
+      _queryParams["cursor"] = cursor;
+    }
     const _response = await (this._options.fetcher ?? fetcher)({
-      url: (0, import_url_join3.default)(
+      url: (0, import_url_join4.default)(
         await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
-        `runner-configs/${encodeURIComponent(runnerName)}`
+        "runners/names"
       ),
-      method: "PUT",
+      method: "GET",
       headers: {
         Authorization: await this._getAuthorizationHeader(),
         "X-Fern-Language": "JavaScript",
@@ -2937,13 +3196,12 @@ var RunnerConfigs = class {
       contentType: "application/json",
       queryParameters: _queryParams,
       requestType: "json",
-      body: RunnerConfigsUpsertRequest.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
       timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
       maxRetries: requestOptions?.maxRetries,
       abortSignal: requestOptions?.abortSignal
     });
     if (_response.ok) {
-      return RunnerConfigsUpsertResponse.parseOrThrow(_response.body, {
+      return RunnersListNamesResponse.parseOrThrow(_response.body, {
         unrecognizedObjectKeys: "passthrough",
         allowUnrecognizedUnionMembers: true,
         allowUnrecognizedEnumValues: true,
@@ -2964,233 +3222,7 @@ var RunnerConfigs = class {
           body: _response.error.rawBody
         });
       case "timeout":
-        throw new RivetTimeoutError("Timeout exceeded when calling PUT /runner-configs/{runner_name}.");
-      case "unknown":
-        throw new RivetError({
-          message: _response.error.errorMessage
-        });
-    }
-  }
-  /**
-   * @param {string} runnerName
-   * @param {Rivet.RunnerConfigsDeleteRequest} request
-   * @param {RunnerConfigs.RequestOptions} requestOptions - Request-specific configuration.
-   *
-   * @example
-   *     await client.runnerConfigs.delete("runner_name", {
-   *         namespace: "namespace"
-   *     })
-   */
-  async delete(runnerName, request, requestOptions) {
-    const { namespace } = request;
-    const _queryParams = {};
-    _queryParams["namespace"] = namespace;
-    const _response = await (this._options.fetcher ?? fetcher)({
-      url: (0, import_url_join3.default)(
-        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
-        `runner-configs/${encodeURIComponent(runnerName)}`
-      ),
-      method: "DELETE",
-      headers: {
-        Authorization: await this._getAuthorizationHeader(),
-        "X-Fern-Language": "JavaScript",
-        "X-Fern-Runtime": RUNTIME.type,
-        "X-Fern-Runtime-Version": RUNTIME.version,
-        ...requestOptions?.headers
-      },
-      contentType: "application/json",
-      queryParameters: _queryParams,
-      requestType: "json",
-      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
-      maxRetries: requestOptions?.maxRetries,
-      abortSignal: requestOptions?.abortSignal
-    });
-    if (_response.ok) {
-      return RunnerConfigsDeleteResponse.parseOrThrow(_response.body, {
-        unrecognizedObjectKeys: "passthrough",
-        allowUnrecognizedUnionMembers: true,
-        allowUnrecognizedEnumValues: true,
-        skipValidation: true,
-        breadcrumbsPrefix: ["response"]
-      });
-    }
-    if (_response.error.reason === "status-code") {
-      throw new RivetError({
-        statusCode: _response.error.statusCode,
-        body: _response.error.body
-      });
-    }
-    switch (_response.error.reason) {
-      case "non-json":
-        throw new RivetError({
-          statusCode: _response.error.statusCode,
-          body: _response.error.rawBody
-        });
-      case "timeout":
-        throw new RivetTimeoutError(
-          "Timeout exceeded when calling DELETE /runner-configs/{runner_name}."
-        );
-      case "unknown":
-        throw new RivetError({
-          message: _response.error.errorMessage
-        });
-    }
-  }
-  async _getAuthorizationHeader() {
-    return `Bearer ${await Supplier.get(this._options.token)}`;
-  }
-};
-
-// src/api/resources/runners/client/Client.ts
-var import_url_join4 = __toESM(require("url-join"));
-var Runners = class {
-  constructor(_options) {
-    this._options = _options;
-  }
-  /**
-   * @param {Rivet.RunnersListRequest} request
-   * @param {Runners.RequestOptions} requestOptions - Request-specific configuration.
-   *
-   * @example
-   *     await client.runners.list({
-   *         namespace: "namespace"
-   *     })
-   */
-  async list(request, requestOptions) {
-    const { namespace, name, runnerIds, includeStopped, limit, cursor } = request;
-    const _queryParams = {};
-    _queryParams["namespace"] = namespace;
-    if (name != null) {
-      _queryParams["name"] = name;
-    }
-    if (runnerIds != null) {
-      _queryParams["runner_ids"] = runnerIds;
-    }
-    if (includeStopped != null) {
-      _queryParams["include_stopped"] = includeStopped.toString();
-    }
-    if (limit != null) {
-      _queryParams["limit"] = limit.toString();
-    }
-    if (cursor != null) {
-      _queryParams["cursor"] = cursor;
-    }
-    const _response = await (this._options.fetcher ?? fetcher)({
-      url: (0, import_url_join4.default)(
-        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
-        "runners"
-      ),
-      method: "GET",
-      headers: {
-        Authorization: await this._getAuthorizationHeader(),
-        "X-Fern-Language": "JavaScript",
-        "X-Fern-Runtime": RUNTIME.type,
-        "X-Fern-Runtime-Version": RUNTIME.version,
-        ...requestOptions?.headers
-      },
-      contentType: "application/json",
-      queryParameters: _queryParams,
-      requestType: "json",
-      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
-      maxRetries: requestOptions?.maxRetries,
-      abortSignal: requestOptions?.abortSignal
-    });
-    if (_response.ok) {
-      return RunnersListResponse.parseOrThrow(_response.body, {
-        unrecognizedObjectKeys: "passthrough",
-        allowUnrecognizedUnionMembers: true,
-        allowUnrecognizedEnumValues: true,
-        skipValidation: true,
-        breadcrumbsPrefix: ["response"]
-      });
-    }
-    if (_response.error.reason === "status-code") {
-      throw new RivetError({
-        statusCode: _response.error.statusCode,
-        body: _response.error.body
-      });
-    }
-    switch (_response.error.reason) {
-      case "non-json":
-        throw new RivetError({
-          statusCode: _response.error.statusCode,
-          body: _response.error.rawBody
-        });
-      case "timeout":
-        throw new RivetTimeoutError("Timeout exceeded when calling GET /runners.");
-      case "unknown":
-        throw new RivetError({
-          message: _response.error.errorMessage
-        });
-    }
-  }
-  /**
-   * 2 round trips:
-   *
-   * - GET /runners/names (fanout)
-   * - [api-peer] namespace::ops::resolve_for_name_global
-   *
-   * @param {Rivet.RunnersListNamesRequest} request
-   * @param {Runners.RequestOptions} requestOptions - Request-specific configuration.
-   *
-   * @example
-   *     await client.runners.listNames({
-   *         namespace: "namespace"
-   *     })
-   */
-  async listNames(request, requestOptions) {
-    const { namespace, limit, cursor } = request;
-    const _queryParams = {};
-    _queryParams["namespace"] = namespace;
-    if (limit != null) {
-      _queryParams["limit"] = limit.toString();
-    }
-    if (cursor != null) {
-      _queryParams["cursor"] = cursor;
-    }
-    const _response = await (this._options.fetcher ?? fetcher)({
-      url: (0, import_url_join4.default)(
-        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
-        "runners/names"
-      ),
-      method: "GET",
-      headers: {
-        Authorization: await this._getAuthorizationHeader(),
-        "X-Fern-Language": "JavaScript",
-        "X-Fern-Runtime": RUNTIME.type,
-        "X-Fern-Runtime-Version": RUNTIME.version,
-        ...requestOptions?.headers
-      },
-      contentType: "application/json",
-      queryParameters: _queryParams,
-      requestType: "json",
-      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
-      maxRetries: requestOptions?.maxRetries,
-      abortSignal: requestOptions?.abortSignal
-    });
-    if (_response.ok) {
-      return RunnersListNamesResponse.parseOrThrow(_response.body, {
-        unrecognizedObjectKeys: "passthrough",
-        allowUnrecognizedUnionMembers: true,
-        allowUnrecognizedEnumValues: true,
-        skipValidation: true,
-        breadcrumbsPrefix: ["response"]
-      });
-    }
-    if (_response.error.reason === "status-code") {
-      throw new RivetError({
-        statusCode: _response.error.statusCode,
-        body: _response.error.body
-      });
-    }
-    switch (_response.error.reason) {
-      case "non-json":
-        throw new RivetError({
-          statusCode: _response.error.statusCode,
-          body: _response.error.rawBody
-        });
-      case "timeout":
-        throw new RivetTimeoutError("Timeout exceeded when calling GET /runners/names.");
+        throw new RivetTimeoutError("Timeout exceeded when calling GET /runners/names.");
       case "unknown":
         throw new RivetError({
           message: _response.error.errorMessage
@@ -3208,18 +3240,18 @@ var RivetClient = class {
     this._options = _options;
   }
   _datacenters;
+  _health;
   _namespaces;
-  _runnerConfigs;
   _runners;
   get datacenters() {
     return this._datacenters ??= new Datacenters(this._options);
   }
+  get health() {
+    return this._health ??= new Health(this._options);
+  }
   get namespaces() {
     return this._namespaces ??= new Namespaces(this._options);
   }
-  get runnerConfigs() {
-    return this._runnerConfigs ??= new RunnerConfigs(this._options);
-  }
   get runners() {
     return this._runners ??= new Runners(this._options);
   }
@@ -3356,12 +3388,9 @@ var RivetClient = class {
    *     })
    */
   async actorsCreate(request, requestOptions) {
-    const { namespace, datacenter, ..._body } = request;
+    const { namespace, ..._body } = request;
     const _queryParams = {};
     _queryParams["namespace"] = namespace;
-    if (datacenter != null) {
-      _queryParams["datacenter"] = datacenter;
-    }
     const _response = await (this._options.fetcher ?? fetcher)({
       url: (0, import_url_join5.default)(
         await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
@@ -3452,12 +3481,9 @@ var RivetClient = class {
    *     })
    */
   async actorsGetOrCreate(request, requestOptions) {
-    const { namespace, datacenter, ..._body } = request;
+    const { namespace, ..._body } = request;
     const _queryParams = {};
     _queryParams["namespace"] = namespace;
-    if (datacenter != null) {
-      _queryParams["datacenter"] = datacenter;
-    }
     const _response = await (this._options.fetcher ?? fetcher)({
       url: (0, import_url_join5.default)(
         await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
@@ -3649,6 +3675,353 @@ var RivetClient = class {
         });
     }
   }
+  /**
+   * @param {Rivet.RunnerConfigsListRequest} request
+   * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.runnerConfigsList({
+   *         namespace: "namespace"
+   *     })
+   */
+  async runnerConfigsList(request, requestOptions) {
+    const { namespace, limit, cursor, variant, runnerNames } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    if (limit != null) {
+      _queryParams["limit"] = limit.toString();
+    }
+    if (cursor != null) {
+      _queryParams["cursor"] = cursor;
+    }
+    if (variant != null) {
+      _queryParams["variant"] = RunnerConfigVariant2.jsonOrThrow(variant, {
+        unrecognizedObjectKeys: "strip"
+      });
+    }
+    if (runnerNames != null) {
+      _queryParams["runner_names"] = runnerNames;
+    }
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join5.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "runner-configs"
+      ),
+      method: "GET",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return RunnerConfigsListResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling GET /runner-configs.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  /**
+   * @param {Rivet.RunnerConfigsServerlessHealthCheckRequest} request
+   * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.runnerConfigsServerlessHealthCheck({
+   *         namespace: "namespace",
+   *         url: "url"
+   *     })
+   */
+  async runnerConfigsServerlessHealthCheck(request, requestOptions) {
+    const { namespace, ..._body } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join5.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        "runner-configs/serverless-health-check"
+      ),
+      method: "POST",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      body: RunnerConfigsServerlessHealthCheckRequest.jsonOrThrow(_body, {
+        unrecognizedObjectKeys: "strip"
+      }),
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return RunnerConfigsServerlessHealthCheckResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError(
+          "Timeout exceeded when calling POST /runner-configs/serverless-health-check."
+        );
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  /**
+   * @param {string} runnerName
+   * @param {Rivet.RunnerConfigsUpsertRequestBody} request
+   * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.runnerConfigsUpsert("runner_name", {
+   *         namespace: "namespace",
+   *         datacenters: {
+   *             "key": {}
+   *         }
+   *     })
+   */
+  async runnerConfigsUpsert(runnerName, request, requestOptions) {
+    const { namespace, ..._body } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join5.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `runner-configs/${encodeURIComponent(runnerName)}`
+      ),
+      method: "PUT",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      body: RunnerConfigsUpsertRequestBody.jsonOrThrow(_body, { unrecognizedObjectKeys: "strip" }),
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return RunnerConfigsUpsertResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError("Timeout exceeded when calling PUT /runner-configs/{runner_name}.");
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  /**
+   * @param {string} runnerName
+   * @param {Rivet.RunnerConfigsDeleteRequest} request
+   * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.runnerConfigsDelete("runner_name", {
+   *         namespace: "namespace"
+   *     })
+   */
+  async runnerConfigsDelete(runnerName, request, requestOptions) {
+    const { namespace } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join5.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `runner-configs/${encodeURIComponent(runnerName)}`
+      ),
+      method: "DELETE",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return RunnerConfigsDeleteResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError(
+          "Timeout exceeded when calling DELETE /runner-configs/{runner_name}."
+        );
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
+  /**
+   * @param {string} runnerName
+   * @param {Rivet.RunnerConfigsRefreshMetadataRequest} request
+   * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+   *
+   * @example
+   *     await client.runnerConfigsRefreshMetadata("runner_name", {
+   *         namespace: "namespace",
+   *         body: {
+   *             "key": "value"
+   *         }
+   *     })
+   */
+  async runnerConfigsRefreshMetadata(runnerName, request, requestOptions) {
+    const { namespace, body: _body } = request;
+    const _queryParams = {};
+    _queryParams["namespace"] = namespace;
+    const _response = await (this._options.fetcher ?? fetcher)({
+      url: (0, import_url_join5.default)(
+        await Supplier.get(this._options.baseUrl) ?? await Supplier.get(this._options.environment),
+        `runner-configs/${encodeURIComponent(runnerName)}/refresh-metadata`
+      ),
+      method: "POST",
+      headers: {
+        Authorization: await this._getAuthorizationHeader(),
+        "X-Fern-Language": "JavaScript",
+        "X-Fern-Runtime": RUNTIME.type,
+        "X-Fern-Runtime-Version": RUNTIME.version,
+        ...requestOptions?.headers
+      },
+      contentType: "application/json",
+      queryParameters: _queryParams,
+      requestType: "json",
+      body: RunnerConfigsRefreshMetadataRequestBody.jsonOrThrow(_body, {
+        unrecognizedObjectKeys: "strip"
+      }),
+      timeoutMs: requestOptions?.timeoutInSeconds != null ? requestOptions.timeoutInSeconds * 1e3 : 18e4,
+      maxRetries: requestOptions?.maxRetries,
+      abortSignal: requestOptions?.abortSignal
+    });
+    if (_response.ok) {
+      return RunnerConfigsRefreshMetadataResponse.parseOrThrow(_response.body, {
+        unrecognizedObjectKeys: "passthrough",
+        allowUnrecognizedUnionMembers: true,
+        allowUnrecognizedEnumValues: true,
+        skipValidation: true,
+        breadcrumbsPrefix: ["response"]
+      });
+    }
+    if (_response.error.reason === "status-code") {
+      throw new RivetError({
+        statusCode: _response.error.statusCode,
+        body: _response.error.body
+      });
+    }
+    switch (_response.error.reason) {
+      case "non-json":
+        throw new RivetError({
+          statusCode: _response.error.statusCode,
+          body: _response.error.rawBody
+        });
+      case "timeout":
+        throw new RivetTimeoutError(
+          "Timeout exceeded when calling POST /runner-configs/{runner_name}/refresh-metadata."
+        );
+      case "unknown":
+        throw new RivetError({
+          message: _response.error.errorMessage
+        });
+    }
+  }
   async _getAuthorizationHeader() {
     return `Bearer ${await Supplier.get(this._options.token)}`;
   }