@rivetkit/engine-api-full 25.7.3 → 25.8.1

package/dist/node/serialization.js

@@ -41,7 +41,11 @@ __export(serialization_exports, {
   ActorsListResponse: () => ActorsListResponse,
   CrashPolicy: () => CrashPolicy,
   Datacenter: () => Datacenter,
+  DatacenterHealth: () => DatacenterHealth,
   DatacentersListResponse: () => DatacentersListResponse,
+  HealthFanoutResponse: () => HealthFanoutResponse,
+  HealthResponse: () => HealthResponse,
+  HealthStatus: () => HealthStatus,
   Namespace: () => Namespace,
   NamespaceListResponse: () => NamespaceListResponse,
   NamespacesCreateRequest: () => NamespacesCreateRequest,
@@ -50,27 +54,41 @@ __export(serialization_exports, {
   RivetId: () => RivetId,
   Runner: () => Runner,
   RunnerConfig: () => RunnerConfig,
+  RunnerConfigKind: () => RunnerConfigKind,
+  RunnerConfigKindNormal: () => RunnerConfigKindNormal,
+  RunnerConfigKindServerless: () => RunnerConfigKindServerless,
+  RunnerConfigKindServerlessServerless: () => RunnerConfigKindServerlessServerless,
   RunnerConfigServerless: () => RunnerConfigServerless,
   RunnerConfigVariant: () => RunnerConfigVariant,
   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_exports,
-  runnerConfigs: () => runnerConfigs_exports
+  namespaces: () => namespaces_exports
 });
 module.exports = __toCommonJS(serialization_exports);
 
-// src/serialization/resources/runnerConfigs/index.ts
-var runnerConfigs_exports = {};
-__export(runnerConfigs_exports, {
-  RunnerConfigsUpsertRequest: () => RunnerConfigsUpsertRequest,
-  RunnerConfigsUpsertRequestServerless: () => RunnerConfigsUpsertRequestServerless
-});
-
 // src/core/fetcher/createRequestUrl.ts
 var import_qs = __toESM(require("qs"));
 
@@ -1534,34 +1552,6 @@ function transformAndValidateUnion({
   };
 }
 
-// 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_exports = {};
-__export(namespaces_exports, {
-  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/serialization/types/RivetId.ts
 var RivetId = schemas_exports.string();
 
@@ -1623,8 +1613,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 HealthStatus = 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: HealthStatus
 });
 
 // src/serialization/types/DatacentersListResponse.ts
@@ -1633,6 +1644,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()),
@@ -1673,37 +1689,177 @@ 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 RunnerConfigVariant = 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());
+var RunnerConfigsUpsertResponse = schemas_exports.object({
+  endpointConfigChanged: schemas_exports.property("endpoint_config_changed", schemas_exports.boolean())
+});
 
 // src/serialization/types/RunnersListNamesResponse.ts
 var RunnersListNamesResponse = schemas_exports.object({
@@ -1720,6 +1876,7 @@ var RunnersListResponse = schemas_exports.object({
 // src/serialization/client/requests/ActorsCreateRequest.ts
 var ActorsCreateRequest = schemas_exports.object({
   crashPolicy: schemas_exports.property("crash_policy", CrashPolicy),
+  datacenter: schemas_exports.string().optional(),
   input: schemas_exports.string().optional(),
   key: schemas_exports.string().optional(),
   name: schemas_exports.string(),
@@ -1729,11 +1886,35 @@ var ActorsCreateRequest = schemas_exports.object({
 // src/serialization/client/requests/ActorsGetOrCreateRequest.ts
 var ActorsGetOrCreateRequest = schemas_exports.object({
   crashPolicy: schemas_exports.property("crash_policy", CrashPolicy),
+  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_exports = {};
+__export(namespaces_exports, {
+  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()
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Actor,
@@ -1747,7 +1928,11 @@ var ActorsGetOrCreateRequest = schemas_exports.object({
   ActorsListResponse,
   CrashPolicy,
   Datacenter,
+  DatacenterHealth,
   DatacentersListResponse,
+  HealthFanoutResponse,
+  HealthResponse,
+  HealthStatus,
   Namespace,
   NamespaceListResponse,
   NamespacesCreateRequest,
@@ -1756,15 +1941,36 @@ var ActorsGetOrCreateRequest = schemas_exports.object({
   RivetId,
   Runner,
   RunnerConfig,
+  RunnerConfigKind,
+  RunnerConfigKindNormal,
+  RunnerConfigKindServerless,
+  RunnerConfigKindServerlessServerless,
   RunnerConfigServerless,
   RunnerConfigVariant,
   RunnerConfigsDeleteResponse,
   RunnerConfigsListResponse,
-  RunnerConfigsUpsertRequest,
-  RunnerConfigsUpsertRequestServerless,
+  RunnerConfigsListResponseRunnerConfigsValue,
+  RunnerConfigsRefreshMetadataRequestBody,
+  RunnerConfigsRefreshMetadataResponse,
+  RunnerConfigsServerlessHealthCheckRequest,
+  RunnerConfigsServerlessHealthCheckResponse,
+  RunnerConfigsServerlessHealthCheckResponseFailure,
+  RunnerConfigsServerlessHealthCheckResponseFailureFailure,
+  RunnerConfigsServerlessHealthCheckResponseSuccess,
+  RunnerConfigsServerlessHealthCheckResponseSuccessSuccess,
+  RunnerConfigsServerlessMetadataError,
+  RunnerConfigsServerlessMetadataErrorInvalidRequest,
+  RunnerConfigsServerlessMetadataErrorInvalidResponseJson,
+  RunnerConfigsServerlessMetadataErrorInvalidResponseJsonInvalidResponseJson,
+  RunnerConfigsServerlessMetadataErrorInvalidResponseSchema,
+  RunnerConfigsServerlessMetadataErrorInvalidResponseSchemaInvalidResponseSchema,
+  RunnerConfigsServerlessMetadataErrorNonSuccessStatus,
+  RunnerConfigsServerlessMetadataErrorNonSuccessStatusNonSuccessStatus,
+  RunnerConfigsServerlessMetadataErrorRequestFailed,
+  RunnerConfigsServerlessMetadataErrorRequestTimedOut,
+  RunnerConfigsUpsertRequestBody,
   RunnerConfigsUpsertResponse,
   RunnersListNamesResponse,
   RunnersListResponse,
-  namespaces,
-  runnerConfigs
+  namespaces
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rivetkit/engine-api-full",
-  "version": "25.7.3",
+  "version": "25.8.1",
   "repository": "https://github.com/rivet-gg/rivet/tree/main/sdks/typescript",
   "files": [
     "dist",

package/types/Client.d.ts

@@ -4,8 +4,8 @@
 import * as core from "./core";
 import * as Rivet from "./api/index";
 import { Datacenters } from "./api/resources/datacenters/client/Client";
+import { Health } from "./api/resources/health/client/Client";
 import { Namespaces } from "./api/resources/namespaces/client/Client";
-import { RunnerConfigs } from "./api/resources/runnerConfigs/client/Client";
 import { Runners } from "./api/resources/runners/client/Client";
 export declare namespace RivetClient {
     interface Options {
@@ -29,13 +29,13 @@ export declare namespace RivetClient {
 export declare class RivetClient {
     protected readonly _options: RivetClient.Options;
     protected _datacenters: Datacenters | undefined;
+    protected _health: Health | undefined;
     protected _namespaces: Namespaces | undefined;
-    protected _runnerConfigs: RunnerConfigs | undefined;
     protected _runners: Runners | undefined;
     constructor(_options: RivetClient.Options);
     get datacenters(): Datacenters;
+    get health(): Health;
     get namespaces(): Namespaces;
-    get runnerConfigs(): RunnerConfigs;
     get runners(): Runners;
     /**
      * **If key is some & `include_destroyed` is false**
@@ -169,5 +169,65 @@ export declare class RivetClient {
      *     await client.actorsDelete("actor_id")
      */
     actorsDelete(actorId: Rivet.RivetId, request?: Rivet.ActorsDeleteRequest, requestOptions?: RivetClient.RequestOptions): Promise<Rivet.ActorsDeleteResponse>;
+    /**
+     * @param {Rivet.RunnerConfigsListRequest} request
+     * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.runnerConfigsList({
+     *         namespace: "namespace"
+     *     })
+     */
+    runnerConfigsList(request: Rivet.RunnerConfigsListRequest, requestOptions?: RivetClient.RequestOptions): Promise<Rivet.RunnerConfigsListResponse>;
+    /**
+     * @param {Rivet.RunnerConfigsServerlessHealthCheckRequest} request
+     * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.runnerConfigsServerlessHealthCheck({
+     *         namespace: "namespace",
+     *         url: "url"
+     *     })
+     */
+    runnerConfigsServerlessHealthCheck(request: Rivet.RunnerConfigsServerlessHealthCheckRequest, requestOptions?: RivetClient.RequestOptions): Promise<Rivet.RunnerConfigsServerlessHealthCheckResponse>;
+    /**
+     * @param {string} runnerName
+     * @param {Rivet.RunnerConfigsUpsertRequestBody} request
+     * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.runnerConfigsUpsert("runner_name", {
+     *         namespace: "namespace",
+     *         datacenters: {
+     *             "key": {}
+     *         }
+     *     })
+     */
+    runnerConfigsUpsert(runnerName: string, request: Rivet.RunnerConfigsUpsertRequestBody, requestOptions?: RivetClient.RequestOptions): Promise<Rivet.RunnerConfigsUpsertResponse>;
+    /**
+     * @param {string} runnerName
+     * @param {Rivet.RunnerConfigsDeleteRequest} request
+     * @param {RivetClient.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.runnerConfigsDelete("runner_name", {
+     *         namespace: "namespace"
+     *     })
+     */
+    runnerConfigsDelete(runnerName: string, request: Rivet.RunnerConfigsDeleteRequest, requestOptions?: RivetClient.RequestOptions): Promise<Rivet.RunnerConfigsDeleteResponse>;
+    /**
+     * @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"
+     *         }
+     *     })
+     */
+    runnerConfigsRefreshMetadata(runnerName: string, request: Rivet.RunnerConfigsRefreshMetadataRequest, requestOptions?: RivetClient.RequestOptions): Promise<Rivet.RunnerConfigsRefreshMetadataResponse>;
     protected _getAuthorizationHeader(): Promise<string>;
 }

package/types/api/client/requests/ActorsCreateRequest.d.ts

@@ -13,8 +13,8 @@ import * as Rivet from "../../index";
  */
 export interface ActorsCreateRequest {
     namespace: string;
-    datacenter?: string;
     crashPolicy: Rivet.CrashPolicy;
+    datacenter?: string;
     input?: string;
     key?: string;
     name: string;

package/types/api/client/requests/ActorsGetOrCreateRequest.d.ts

@@ -14,8 +14,8 @@ import * as Rivet from "../../index";
  */
 export interface ActorsGetOrCreateRequest {
     namespace: string;
-    datacenter?: string;
     crashPolicy: Rivet.CrashPolicy;
+    datacenter?: string;
     input?: string;
     key: string;
     name: string;

package/types/api/{resources/runnerConfigs/client → client}/requests/RunnerConfigsListRequest.d.ts

@@ -1,7 +1,7 @@
 /**
  * This file was auto-generated by Fern from our API Definition.
  */
-import * as Rivet from "../../../../index";
+import * as Rivet from "../../index";
 /**
  * @example
  *     {

package/types/api/client/requests/RunnerConfigsRefreshMetadataRequest.d.ts

@@ -0,0 +1,17 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as Rivet from "../../index";
+/**
+ * @example
+ *     {
+ *         namespace: "namespace",
+ *         body: {
+ *             "key": "value"
+ *         }
+ *     }
+ */
+export interface RunnerConfigsRefreshMetadataRequest {
+    namespace: string;
+    body: Rivet.RunnerConfigsRefreshMetadataRequestBody;
+}

package/types/api/client/requests/RunnerConfigsServerlessHealthCheckRequest.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+/**
+ * @example
+ *     {
+ *         namespace: "namespace",
+ *         url: "url"
+ *     }
+ */
+export interface RunnerConfigsServerlessHealthCheckRequest {
+    namespace: string;
+    headers?: Record<string, string>;
+    url: string;
+}

package/types/api/client/requests/RunnerConfigsUpsertRequestBody.d.ts

@@ -0,0 +1,17 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as Rivet from "../../index";
+/**
+ * @example
+ *     {
+ *         namespace: "namespace",
+ *         datacenters: {
+ *             "key": {}
+ *         }
+ *     }
+ */
+export interface RunnerConfigsUpsertRequestBody {
+    namespace: string;
+    datacenters: Record<string, Rivet.RunnerConfig>;
+}

package/types/api/client/requests/index.d.ts

@@ -3,3 +3,8 @@ export { type ActorsCreateRequest } from "./ActorsCreateRequest";
 export { type ActorsGetOrCreateRequest } from "./ActorsGetOrCreateRequest";
 export { type ActorsListNamesRequest } from "./ActorsListNamesRequest";
 export { type ActorsDeleteRequest } from "./ActorsDeleteRequest";
+export { type RunnerConfigsListRequest } from "./RunnerConfigsListRequest";
+export { type RunnerConfigsServerlessHealthCheckRequest } from "./RunnerConfigsServerlessHealthCheckRequest";
+export { type RunnerConfigsUpsertRequestBody } from "./RunnerConfigsUpsertRequestBody";
+export { type RunnerConfigsDeleteRequest } from "./RunnerConfigsDeleteRequest";
+export { type RunnerConfigsRefreshMetadataRequest } from "./RunnerConfigsRefreshMetadataRequest";

package/types/api/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./resources";
 export * from "./types";
+export * from "./resources";
 export * from "./client";

package/types/api/resources/health/client/Client.d.ts

@@ -0,0 +1,36 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as core from "../../../../core";
+import * as Rivet from "../../../index";
+export declare namespace Health {
+    interface Options {
+        environment: core.Supplier<string>;
+        /** Specify a custom URL to connect the client to. */
+        baseUrl?: core.Supplier<string>;
+        token: core.Supplier<core.BearerToken>;
+        fetcher?: core.FetchFunction;
+    }
+    interface RequestOptions {
+        /** The maximum time to wait for a response in seconds. */
+        timeoutInSeconds?: number;
+        /** The number of times to retry the request. Defaults to 2. */
+        maxRetries?: number;
+        /** A hook to abort the request. */
+        abortSignal?: AbortSignal;
+        /** Additional headers to include in the request. */
+        headers?: Record<string, string>;
+    }
+}
+export declare class Health {
+    protected readonly _options: Health.Options;
+    constructor(_options: Health.Options);
+    /**
+     * @param {Health.RequestOptions} requestOptions - Request-specific configuration.
+     *
+     * @example
+     *     await client.health.fanout()
+     */
+    fanout(requestOptions?: Health.RequestOptions): Promise<Rivet.HealthFanoutResponse>;
+    protected _getAuthorizationHeader(): Promise<string>;
+}

package/types/api/resources/health/client/index.d.ts

@@ -0,0 +1 @@
+export {};

package/types/{serialization/resources/runnerConfigs → api/resources/health}/index.d.ts

@@ -1,2 +1 @@
-export * from "./types";
 export * from "./client";