@rivetkit/engine-api-full 25.5.3

package/dist/browser/cjs/serialization.js

@@ -0,0 +1,1744 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/serialization/index.ts
+var serialization_exports = {};
+__export(serialization_exports, {
+  Actor: () => Actor,
+  ActorName: () => ActorName,
+  ActorsCreateRequest: () => ActorsCreateRequest,
+  ActorsCreateResponse: () => ActorsCreateResponse,
+  ActorsDeleteResponse: () => ActorsDeleteResponse,
+  ActorsGetByIdResponse: () => ActorsGetByIdResponse,
+  ActorsGetOrCreateByIdRequest: () => ActorsGetOrCreateByIdRequest,
+  ActorsGetOrCreateByIdResponse: () => ActorsGetOrCreateByIdResponse,
+  ActorsGetOrCreateRequest: () => ActorsGetOrCreateRequest,
+  ActorsGetOrCreateResponse: () => ActorsGetOrCreateResponse,
+  ActorsGetResponse: () => ActorsGetResponse,
+  ActorsListNamesResponse: () => ActorsListNamesResponse,
+  ActorsListResponse: () => ActorsListResponse,
+  CrashPolicy: () => CrashPolicy,
+  Datacenter: () => Datacenter,
+  DatacentersListResponse: () => DatacentersListResponse,
+  Namespace: () => Namespace,
+  NamespacesCreateRequest: () => NamespacesCreateRequest,
+  NamespacesCreateResponse: () => NamespacesCreateResponse,
+  NamespacesGetResponse: () => NamespacesGetResponse,
+  NamespacesListResponse: () => NamespacesListResponse,
+  Pagination: () => Pagination,
+  RivetId: () => RivetId,
+  Runner: () => Runner,
+  RunnersGetResponse: () => RunnersGetResponse,
+  RunnersListNamesResponse: () => RunnersListNamesResponse,
+  RunnersListResponse: () => RunnersListResponse,
+  StringHttpAddressHashableMap: () => StringHttpAddressHashableMap,
+  StringHttpAddressHashableMapValue: () => StringHttpAddressHashableMapValue,
+  StringTcpAddressHashableMap: () => StringTcpAddressHashableMap,
+  StringTcpAddressHashableMapValue: () => StringTcpAddressHashableMapValue,
+  StringUdpAddressHashableMap: () => StringUdpAddressHashableMap,
+  StringUdpAddressHashableMapValue: () => StringUdpAddressHashableMapValue,
+  namespaces: () => namespaces_exports
+});
+module.exports = __toCommonJS(serialization_exports);
+
+// src/core/fetcher/createRequestUrl.ts
+var import_qs = __toESM(require("qs"));
+
+// src/core/runtime/runtime.ts
+var RUNTIME = evaluateRuntime();
+function evaluateRuntime() {
+  const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+  if (isBrowser) {
+    return {
+      type: "browser",
+      version: window.navigator.userAgent
+    };
+  }
+  const isCloudflare = typeof globalThis !== "undefined" && globalThis?.navigator?.userAgent === "Cloudflare-Workers";
+  if (isCloudflare) {
+    return {
+      type: "workerd"
+    };
+  }
+  const isEdgeRuntime = typeof EdgeRuntime === "string";
+  if (isEdgeRuntime) {
+    return {
+      type: "edge-runtime"
+    };
+  }
+  const isWebWorker = typeof self === "object" && // @ts-ignore
+  typeof self?.importScripts === "function" && (self.constructor?.name === "DedicatedWorkerGlobalScope" || self.constructor?.name === "ServiceWorkerGlobalScope" || self.constructor?.name === "SharedWorkerGlobalScope");
+  if (isWebWorker) {
+    return {
+      type: "web-worker"
+    };
+  }
+  const isDeno = typeof Deno !== "undefined" && typeof Deno.version !== "undefined" && typeof Deno.version.deno !== "undefined";
+  if (isDeno) {
+    return {
+      type: "deno",
+      version: Deno.version.deno
+    };
+  }
+  const isBun = typeof Bun !== "undefined" && typeof Bun.version !== "undefined";
+  if (isBun) {
+    return {
+      type: "bun",
+      version: Bun.version
+    };
+  }
+  const isNode = typeof process !== "undefined" && "version" in process && !!process.version && "versions" in process && !!process.versions?.node;
+  if (isNode) {
+    return {
+      type: "node",
+      version: process.versions.node,
+      parsedVersion: Number(process.versions.node.split(".")[0])
+    };
+  }
+  const isReactNative = typeof navigator !== "undefined" && navigator?.product === "ReactNative";
+  if (isReactNative) {
+    return {
+      type: "react-native"
+    };
+  }
+  return {
+    type: "unknown"
+  };
+}
+
+// src/core/schemas/index.ts
+var schemas_exports = {};
+__export(schemas_exports, {
+  JsonError: () => JsonError,
+  ParseError: () => ParseError,
+  any: () => any,
+  bigint: () => bigint,
+  boolean: () => boolean,
+  booleanLiteral: () => booleanLiteral,
+  date: () => date,
+  discriminant: () => discriminant,
+  enum_: () => enum_,
+  getObjectLikeUtils: () => getObjectLikeUtils,
+  getObjectUtils: () => getObjectUtils,
+  getSchemaUtils: () => getSchemaUtils,
+  isProperty: () => isProperty,
+  lazy: () => lazy,
+  lazyObject: () => lazyObject,
+  list: () => list,
+  number: () => number,
+  object: () => object,
+  objectWithoutOptionalProperties: () => objectWithoutOptionalProperties,
+  optional: () => optional,
+  property: () => property,
+  record: () => record,
+  set: () => set,
+  string: () => string,
+  stringLiteral: () => stringLiteral,
+  transform: () => transform,
+  undiscriminatedUnion: () => undiscriminatedUnion,
+  union: () => union,
+  unknown: () => unknown,
+  withParsedProperties: () => withParsedProperties
+});
+
+// src/core/schemas/Schema.ts
+var SchemaType = {
+  BIGINT: "bigint",
+  DATE: "date",
+  ENUM: "enum",
+  LIST: "list",
+  STRING_LITERAL: "stringLiteral",
+  BOOLEAN_LITERAL: "booleanLiteral",
+  OBJECT: "object",
+  ANY: "any",
+  BOOLEAN: "boolean",
+  NUMBER: "number",
+  STRING: "string",
+  UNKNOWN: "unknown",
+  RECORD: "record",
+  SET: "set",
+  UNION: "union",
+  UNDISCRIMINATED_UNION: "undiscriminatedUnion",
+  NULLABLE: "nullable",
+  OPTIONAL: "optional",
+  OPTIONAL_NULLABLE: "optionalNullable"
+};
+
+// src/core/schemas/utils/getErrorMessageForIncorrectType.ts
+function getErrorMessageForIncorrectType(value, expectedType) {
+  return `Expected ${expectedType}. Received ${getTypeAsString(value)}.`;
+}
+function getTypeAsString(value) {
+  if (Array.isArray(value)) {
+    return "list";
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (value instanceof BigInt) {
+    return "BigInt";
+  }
+  switch (typeof value) {
+    case "string":
+      return `"${value}"`;
+    case "bigint":
+    case "number":
+    case "boolean":
+    case "undefined":
+      return `${value}`;
+  }
+  return typeof value;
+}
+
+// src/core/schemas/utils/maybeSkipValidation.ts
+function maybeSkipValidation(schema) {
+  return {
+    ...schema,
+    json: transformAndMaybeSkipValidation(schema.json),
+    parse: transformAndMaybeSkipValidation(schema.parse)
+  };
+}
+function transformAndMaybeSkipValidation(transform2) {
+  return (value, opts) => {
+    const transformed = transform2(value, opts);
+    const { skipValidation = false } = opts ?? {};
+    if (!transformed.ok && skipValidation) {
+      console.warn(
+        [
+          "Failed to validate.",
+          ...transformed.errors.map(
+            (error) => "  - " + (error.path.length > 0 ? `${error.path.join(".")}: ${error.message}` : error.message)
+          )
+        ].join("\n")
+      );
+      return {
+        ok: true,
+        value
+      };
+    } else {
+      return transformed;
+    }
+  };
+}
+
+// src/core/schemas/builders/schema-utils/stringifyValidationErrors.ts
+function stringifyValidationError(error) {
+  if (error.path.length === 0) {
+    return error.message;
+  }
+  return `${error.path.join(" -> ")}: ${error.message}`;
+}
+
+// src/core/schemas/builders/schema-utils/JsonError.ts
+var JsonError = class _JsonError extends Error {
+  constructor(errors) {
+    super(errors.map(stringifyValidationError).join("; "));
+    this.errors = errors;
+    Object.setPrototypeOf(this, _JsonError.prototype);
+  }
+};
+
+// src/core/schemas/builders/schema-utils/ParseError.ts
+var ParseError = class _ParseError extends Error {
+  constructor(errors) {
+    super(errors.map(stringifyValidationError).join("; "));
+    this.errors = errors;
+    Object.setPrototypeOf(this, _ParseError.prototype);
+  }
+};
+
+// src/core/schemas/builders/schema-utils/getSchemaUtils.ts
+function getSchemaUtils(schema) {
+  return {
+    nullable: () => nullable(schema),
+    optional: () => optional(schema),
+    optionalNullable: () => optionalNullable(schema),
+    transform: (transformer) => transform(schema, transformer),
+    parseOrThrow: (raw, opts) => {
+      const parsed = schema.parse(raw, opts);
+      if (parsed.ok) {
+        return parsed.value;
+      }
+      throw new ParseError(parsed.errors);
+    },
+    jsonOrThrow: (parsed, opts) => {
+      const raw = schema.json(parsed, opts);
+      if (raw.ok) {
+        return raw.value;
+      }
+      throw new JsonError(raw.errors);
+    }
+  };
+}
+function nullable(schema) {
+  const baseSchema = {
+    parse: (raw, opts) => {
+      if (raw == null) {
+        return {
+          ok: true,
+          value: null
+        };
+      }
+      return schema.parse(raw, opts);
+    },
+    json: (parsed, opts) => {
+      if (parsed == null) {
+        return {
+          ok: true,
+          value: null
+        };
+      }
+      return schema.json(parsed, opts);
+    },
+    getType: () => SchemaType.NULLABLE
+  };
+  return {
+    ...baseSchema,
+    ...getSchemaUtils(baseSchema)
+  };
+}
+function optional(schema) {
+  const baseSchema = {
+    parse: (raw, opts) => {
+      if (raw == null) {
+        return {
+          ok: true,
+          value: void 0
+        };
+      }
+      return schema.parse(raw, opts);
+    },
+    json: (parsed, opts) => {
+      if (opts?.omitUndefined && parsed === void 0) {
+        return {
+          ok: true,
+          value: void 0
+        };
+      }
+      if (parsed == null) {
+        return {
+          ok: true,
+          value: null
+        };
+      }
+      return schema.json(parsed, opts);
+    },
+    getType: () => SchemaType.OPTIONAL
+  };
+  return {
+    ...baseSchema,
+    ...getSchemaUtils(baseSchema)
+  };
+}
+function optionalNullable(schema) {
+  const baseSchema = {
+    parse: (raw, opts) => {
+      if (raw === void 0) {
+        return {
+          ok: true,
+          value: void 0
+        };
+      }
+      if (raw === null) {
+        return {
+          ok: true,
+          value: null
+        };
+      }
+      return schema.parse(raw, opts);
+    },
+    json: (parsed, opts) => {
+      if (parsed === void 0) {
+        return {
+          ok: true,
+          value: void 0
+        };
+      }
+      if (parsed === null) {
+        return {
+          ok: true,
+          value: null
+        };
+      }
+      return schema.json(parsed, opts);
+    },
+    getType: () => SchemaType.OPTIONAL_NULLABLE
+  };
+  return {
+    ...baseSchema,
+    ...getSchemaUtils(baseSchema)
+  };
+}
+function transform(schema, transformer) {
+  const baseSchema = {
+    parse: (raw, opts) => {
+      const parsed = schema.parse(raw, opts);
+      if (!parsed.ok) {
+        return parsed;
+      }
+      return {
+        ok: true,
+        value: transformer.transform(parsed.value)
+      };
+    },
+    json: (transformed, opts) => {
+      const parsed = transformer.untransform(transformed);
+      return schema.json(parsed, opts);
+    },
+    getType: () => schema.getType()
+  };
+  return {
+    ...baseSchema,
+    ...getSchemaUtils(baseSchema)
+  };
+}
+
+// src/core/schemas/builders/bigint/bigint.ts
+function bigint() {
+  const baseSchema = {
+    parse: (raw, { breadcrumbsPrefix = [] } = {}) => {
+      if (typeof raw === "bigint") {
+        return {
+          ok: true,
+          value: raw
+        };
+      }
+      if (typeof raw === "number") {
+        return {
+          ok: true,
+          value: BigInt(raw)
+        };
+      }
+      return {
+        ok: false,
+        errors: [
+          {
+            path: breadcrumbsPrefix,
+            message: getErrorMessageForIncorrectType(raw, "bigint | number")
+          }
+        ]
+      };
+    },
+    json: (bigint2, { breadcrumbsPrefix = [] } = {}) => {
+      if (typeof bigint2 !== "bigint") {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: breadcrumbsPrefix,
+              message: getErrorMessageForIncorrectType(bigint2, "bigint")
+            }
+          ]
+        };
+      }
+      return {
+        ok: true,
+        value: bigint2
+      };
+    },
+    getType: () => SchemaType.BIGINT
+  };
+  return {
+    ...maybeSkipValidation(baseSchema),
+    ...getSchemaUtils(baseSchema)
+  };
+}
+
+// src/core/schemas/builders/date/date.ts
+var ISO_8601_REGEX = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([.,]\d+(?!:))?)?(\17[0-5]\d([.,]\d+)?)?([zZ]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
+function date() {
+  const baseSchema = {
+    parse: (raw, { breadcrumbsPrefix = [] } = {}) => {
+      if (typeof raw !== "string") {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: breadcrumbsPrefix,
+              message: getErrorMessageForIncorrectType(raw, "string")
+            }
+          ]
+        };
+      }
+      if (!ISO_8601_REGEX.test(raw)) {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: breadcrumbsPrefix,
+              message: getErrorMessageForIncorrectType(raw, "ISO 8601 date string")
+            }
+          ]
+        };
+      }
+      return {
+        ok: true,
+        value: new Date(raw)
+      };
+    },
+    json: (date2, { breadcrumbsPrefix = [] } = {}) => {
+      if (date2 instanceof Date) {
+        return {
+          ok: true,
+          value: date2.toISOString()
+        };
+      } else {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: breadcrumbsPrefix,
+              message: getErrorMessageForIncorrectType(date2, "Date object")
+            }
+          ]
+        };
+      }
+    },
+    getType: () => SchemaType.DATE
+  };
+  return {
+    ...maybeSkipValidation(baseSchema),
+    ...getSchemaUtils(baseSchema)
+  };
+}
+
+// src/core/schemas/utils/createIdentitySchemaCreator.ts
+function createIdentitySchemaCreator(schemaType, validate) {
+  return () => {
+    const baseSchema = {
+      parse: validate,
+      json: validate,
+      getType: () => schemaType
+    };
+    return {
+      ...maybeSkipValidation(baseSchema),
+      ...getSchemaUtils(baseSchema)
+    };
+  };
+}
+
+// src/core/schemas/builders/enum/enum.ts
+function enum_(values) {
+  const validValues = new Set(values);
+  const schemaCreator = createIdentitySchemaCreator(
+    SchemaType.ENUM,
+    (value, { allowUnrecognizedEnumValues, breadcrumbsPrefix = [] } = {}) => {
+      if (typeof value !== "string") {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: breadcrumbsPrefix,
+              message: getErrorMessageForIncorrectType(value, "string")
+            }
+          ]
+        };
+      }
+      if (!validValues.has(value) && !allowUnrecognizedEnumValues) {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: breadcrumbsPrefix,
+              message: getErrorMessageForIncorrectType(value, "enum")
+            }
+          ]
+        };
+      }
+      return {
+        ok: true,
+        value
+      };
+    }
+  );
+  return schemaCreator();
+}
+
+// src/core/schemas/builders/lazy/lazy.ts
+function lazy(getter) {
+  const baseSchema = constructLazyBaseSchema(getter);
+  return {
+    ...baseSchema,
+    ...getSchemaUtils(baseSchema)
+  };
+}
+function constructLazyBaseSchema(getter) {
+  return {
+    parse: (raw, opts) => getMemoizedSchema(getter).parse(raw, opts),
+    json: (parsed, opts) => getMemoizedSchema(getter).json(parsed, opts),
+    getType: () => getMemoizedSchema(getter).getType()
+  };
+}
+function getMemoizedSchema(getter) {
+  const castedGetter = getter;
+  if (castedGetter.__zurg_memoized == null) {
+    castedGetter.__zurg_memoized = getter();
+  }
+  return castedGetter.__zurg_memoized;
+}
+
+// src/core/schemas/utils/entries.ts
+function entries(object2) {
+  return Object.entries(object2);
+}
+
+// src/core/schemas/utils/filterObject.ts
+function filterObject(obj, keysToInclude) {
+  const keysToIncludeSet = new Set(keysToInclude);
+  return Object.entries(obj).reduce(
+    (acc, [key, value]) => {
+      if (keysToIncludeSet.has(key)) {
+        acc[key] = value;
+      }
+      return acc;
+    },
+    {}
+  );
+}
+
+// src/core/schemas/utils/isPlainObject.ts
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (Object.getPrototypeOf(value) === null) {
+    return true;
+  }
+  let proto = value;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(value) === proto;
+}
+
+// src/core/schemas/utils/keys.ts
+function keys(object2) {
+  return Object.keys(object2);
+}
+
+// src/core/schemas/utils/partition.ts
+function partition(items, predicate) {
+  const trueItems = [], falseItems = [];
+  for (const item of items) {
+    if (predicate(item)) {
+      trueItems.push(item);
+    } else {
+      falseItems.push(item);
+    }
+  }
+  return [trueItems, falseItems];
+}
+
+// src/core/schemas/builders/object-like/getObjectLikeUtils.ts
+function getObjectLikeUtils(schema) {
+  return {
+    withParsedProperties: (properties) => withParsedProperties(schema, properties)
+  };
+}
+function withParsedProperties(objectLike, properties) {
+  const objectSchema = {
+    parse: (raw, opts) => {
+      const parsedObject = objectLike.parse(raw, opts);
+      if (!parsedObject.ok) {
+        return parsedObject;
+      }
+      const additionalProperties = Object.entries(properties).reduce(
+        (processed, [key, value]) => {
+          return {
+            ...processed,
+            [key]: typeof value === "function" ? value(parsedObject.value) : value
+          };
+        },
+        {}
+      );
+      return {
+        ok: true,
+        value: {
+          ...parsedObject.value,
+          ...additionalProperties
+        }
+      };
+    },
+    json: (parsed, opts) => {
+      if (!isPlainObject(parsed)) {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: opts?.breadcrumbsPrefix ?? [],
+              message: getErrorMessageForIncorrectType(parsed, "object")
+            }
+          ]
+        };
+      }
+      const addedPropertyKeys = new Set(Object.keys(properties));
+      const parsedWithoutAddedProperties = filterObject(
+        parsed,
+        Object.keys(parsed).filter((key) => !addedPropertyKeys.has(key))
+      );
+      return objectLike.json(parsedWithoutAddedProperties, opts);
+    },
+    getType: () => objectLike.getType()
+  };
+  return {
+    ...objectSchema,
+    ...getSchemaUtils(objectSchema),
+    ...getObjectLikeUtils(objectSchema)
+  };
+}
+
+// src/core/schemas/builders/object/property.ts
+function property(rawKey, valueSchema) {
+  return {
+    rawKey,
+    valueSchema,
+    isProperty: true
+  };
+}
+function isProperty(maybeProperty) {
+  return maybeProperty.isProperty;
+}
+
+// src/core/schemas/builders/object/object.ts
+function object(schemas) {
+  const baseSchema = {
+    _getRawProperties: () => Object.entries(schemas).map(
+      ([parsedKey, propertySchema]) => isProperty(propertySchema) ? propertySchema.rawKey : parsedKey
+    ),
+    _getParsedProperties: () => keys(schemas),
+    parse: (raw, opts) => {
+      const rawKeyToProperty = {};
+      const requiredKeys = [];
+      for (const [parsedKey, schemaOrObjectProperty] of entries(schemas)) {
+        const rawKey = isProperty(schemaOrObjectProperty) ? schemaOrObjectProperty.rawKey : parsedKey;
+        const valueSchema = isProperty(schemaOrObjectProperty) ? schemaOrObjectProperty.valueSchema : schemaOrObjectProperty;
+        const property2 = {
+          rawKey,
+          parsedKey,
+          valueSchema
+        };
+        rawKeyToProperty[rawKey] = property2;
+        if (isSchemaRequired(valueSchema)) {
+          requiredKeys.push(rawKey);
+        }
+      }
+      return validateAndTransformObject({
+        value: raw,
+        requiredKeys,
+        getProperty: (rawKey) => {
+          const property2 = rawKeyToProperty[rawKey];
+          if (property2 == null) {
+            return void 0;
+          }
+          return {
+            transformedKey: property2.parsedKey,
+            transform: (propertyValue) => property2.valueSchema.parse(propertyValue, {
+              ...opts,
+              breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], rawKey]
+            })
+          };
+        },
+        unrecognizedObjectKeys: opts?.unrecognizedObjectKeys,
+        skipValidation: opts?.skipValidation,
+        breadcrumbsPrefix: opts?.breadcrumbsPrefix,
+        omitUndefined: opts?.omitUndefined
+      });
+    },
+    json: (parsed, opts) => {
+      const requiredKeys = [];
+      for (const [parsedKey, schemaOrObjectProperty] of entries(schemas)) {
+        const valueSchema = isProperty(schemaOrObjectProperty) ? schemaOrObjectProperty.valueSchema : schemaOrObjectProperty;
+        if (isSchemaRequired(valueSchema)) {
+          requiredKeys.push(parsedKey);
+        }
+      }
+      return validateAndTransformObject({
+        value: parsed,
+        requiredKeys,
+        getProperty: (parsedKey) => {
+          const property2 = schemas[parsedKey];
+          if (property2 == null) {
+            return void 0;
+          }
+          if (isProperty(property2)) {
+            return {
+              transformedKey: property2.rawKey,
+              transform: (propertyValue) => property2.valueSchema.json(propertyValue, {
+                ...opts,
+                breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], parsedKey]
+              })
+            };
+          } else {
+            return {
+              transformedKey: parsedKey,
+              transform: (propertyValue) => property2.json(propertyValue, {
+                ...opts,
+                breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], parsedKey]
+              })
+            };
+          }
+        },
+        unrecognizedObjectKeys: opts?.unrecognizedObjectKeys,
+        skipValidation: opts?.skipValidation,
+        breadcrumbsPrefix: opts?.breadcrumbsPrefix,
+        omitUndefined: opts?.omitUndefined
+      });
+    },
+    getType: () => SchemaType.OBJECT
+  };
+  return {
+    ...maybeSkipValidation(baseSchema),
+    ...getSchemaUtils(baseSchema),
+    ...getObjectLikeUtils(baseSchema),
+    ...getObjectUtils(baseSchema)
+  };
+}
+function validateAndTransformObject({
+  value,
+  requiredKeys,
+  getProperty,
+  unrecognizedObjectKeys = "fail",
+  skipValidation = false,
+  breadcrumbsPrefix = []
+}) {
+  if (!isPlainObject(value)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: breadcrumbsPrefix,
+          message: getErrorMessageForIncorrectType(value, "object")
+        }
+      ]
+    };
+  }
+  const missingRequiredKeys = new Set(requiredKeys);
+  const errors = [];
+  const transformed = {};
+  for (const [preTransformedKey, preTransformedItemValue] of Object.entries(value)) {
+    const property2 = getProperty(preTransformedKey);
+    if (property2 != null) {
+      missingRequiredKeys.delete(preTransformedKey);
+      const value2 = property2.transform(preTransformedItemValue);
+      if (value2.ok) {
+        transformed[property2.transformedKey] = value2.value;
+      } else {
+        transformed[preTransformedKey] = preTransformedItemValue;
+        errors.push(...value2.errors);
+      }
+    } else {
+      switch (unrecognizedObjectKeys) {
+        case "fail":
+          errors.push({
+            path: [...breadcrumbsPrefix, preTransformedKey],
+            message: `Unexpected key "${preTransformedKey}"`
+          });
+          break;
+        case "strip":
+          break;
+        case "passthrough":
+          transformed[preTransformedKey] = preTransformedItemValue;
+          break;
+      }
+    }
+  }
+  errors.push(
+    ...requiredKeys.filter((key) => missingRequiredKeys.has(key)).map((key) => ({
+      path: breadcrumbsPrefix,
+      message: `Missing required key "${key}"`
+    }))
+  );
+  if (errors.length === 0 || skipValidation) {
+    return {
+      ok: true,
+      value: transformed
+    };
+  } else {
+    return {
+      ok: false,
+      errors
+    };
+  }
+}
+function getObjectUtils(schema) {
+  return {
+    extend: (extension) => {
+      const baseSchema = {
+        _getParsedProperties: () => [...schema._getParsedProperties(), ...extension._getParsedProperties()],
+        _getRawProperties: () => [...schema._getRawProperties(), ...extension._getRawProperties()],
+        parse: (raw, opts) => {
+          return validateAndTransformExtendedObject({
+            extensionKeys: extension._getRawProperties(),
+            value: raw,
+            transformBase: (rawBase) => schema.parse(rawBase, opts),
+            transformExtension: (rawExtension) => extension.parse(rawExtension, opts)
+          });
+        },
+        json: (parsed, opts) => {
+          return validateAndTransformExtendedObject({
+            extensionKeys: extension._getParsedProperties(),
+            value: parsed,
+            transformBase: (parsedBase) => schema.json(parsedBase, opts),
+            transformExtension: (parsedExtension) => extension.json(parsedExtension, opts)
+          });
+        },
+        getType: () => SchemaType.OBJECT
+      };
+      return {
+        ...baseSchema,
+        ...getSchemaUtils(baseSchema),
+        ...getObjectLikeUtils(baseSchema),
+        ...getObjectUtils(baseSchema)
+      };
+    },
+    passthrough: () => {
+      const baseSchema = {
+        _getParsedProperties: () => schema._getParsedProperties(),
+        _getRawProperties: () => schema._getRawProperties(),
+        parse: (raw, opts) => {
+          const transformed = schema.parse(raw, { ...opts, unrecognizedObjectKeys: "passthrough" });
+          if (!transformed.ok) {
+            return transformed;
+          }
+          return {
+            ok: true,
+            value: {
+              ...raw,
+              ...transformed.value
+            }
+          };
+        },
+        json: (parsed, opts) => {
+          const transformed = schema.json(parsed, { ...opts, unrecognizedObjectKeys: "passthrough" });
+          if (!transformed.ok) {
+            return transformed;
+          }
+          return {
+            ok: true,
+            value: {
+              ...parsed,
+              ...transformed.value
+            }
+          };
+        },
+        getType: () => SchemaType.OBJECT
+      };
+      return {
+        ...baseSchema,
+        ...getSchemaUtils(baseSchema),
+        ...getObjectLikeUtils(baseSchema),
+        ...getObjectUtils(baseSchema)
+      };
+    }
+  };
+}
+function validateAndTransformExtendedObject({
+  extensionKeys,
+  value,
+  transformBase,
+  transformExtension
+}) {
+  const extensionPropertiesSet = new Set(extensionKeys);
+  const [extensionProperties, baseProperties] = partition(
+    keys(value),
+    (key) => extensionPropertiesSet.has(key)
+  );
+  const transformedBase = transformBase(filterObject(value, baseProperties));
+  const transformedExtension = transformExtension(filterObject(value, extensionProperties));
+  if (transformedBase.ok && transformedExtension.ok) {
+    return {
+      ok: true,
+      value: {
+        ...transformedBase.value,
+        ...transformedExtension.value
+      }
+    };
+  } else {
+    return {
+      ok: false,
+      errors: [
+        ...transformedBase.ok ? [] : transformedBase.errors,
+        ...transformedExtension.ok ? [] : transformedExtension.errors
+      ]
+    };
+  }
+}
+function isSchemaRequired(schema) {
+  return !isSchemaOptional(schema);
+}
+function isSchemaOptional(schema) {
+  switch (schema.getType()) {
+    case SchemaType.ANY:
+    case SchemaType.UNKNOWN:
+    case SchemaType.OPTIONAL:
+    case SchemaType.OPTIONAL_NULLABLE:
+      return true;
+    default:
+      return false;
+  }
+}
+
+// src/core/schemas/builders/object/objectWithoutOptionalProperties.ts
+function objectWithoutOptionalProperties(schemas) {
+  return object(schemas);
+}
+
+// src/core/schemas/builders/lazy/lazyObject.ts
+function lazyObject(getter) {
+  const baseSchema = {
+    ...constructLazyBaseSchema(getter),
+    _getRawProperties: () => getMemoizedSchema(getter)._getRawProperties(),
+    _getParsedProperties: () => getMemoizedSchema(getter)._getParsedProperties()
+  };
+  return {
+    ...baseSchema,
+    ...getSchemaUtils(baseSchema),
+    ...getObjectLikeUtils(baseSchema),
+    ...getObjectUtils(baseSchema)
+  };
+}
+
+// src/core/schemas/builders/list/list.ts
+function list(schema) {
+  const baseSchema = {
+    parse: (raw, opts) => validateAndTransformArray(
+      raw,
+      (item, index) => schema.parse(item, {
+        ...opts,
+        breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], `[${index}]`]
+      })
+    ),
+    json: (parsed, opts) => validateAndTransformArray(
+      parsed,
+      (item, index) => schema.json(item, {
+        ...opts,
+        breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], `[${index}]`]
+      })
+    ),
+    getType: () => SchemaType.LIST
+  };
+  return {
+    ...maybeSkipValidation(baseSchema),
+    ...getSchemaUtils(baseSchema)
+  };
+}
+function validateAndTransformArray(value, transformItem) {
+  if (!Array.isArray(value)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          message: getErrorMessageForIncorrectType(value, "list"),
+          path: []
+        }
+      ]
+    };
+  }
+  const maybeValidItems = value.map((item, index) => transformItem(item, index));
+  return maybeValidItems.reduce(
+    (acc, item) => {
+      if (acc.ok && item.ok) {
+        return {
+          ok: true,
+          value: [...acc.value, item.value]
+        };
+      }
+      const errors = [];
+      if (!acc.ok) {
+        errors.push(...acc.errors);
+      }
+      if (!item.ok) {
+        errors.push(...item.errors);
+      }
+      return {
+        ok: false,
+        errors
+      };
+    },
+    { ok: true, value: [] }
+  );
+}
+
+// src/core/schemas/builders/literals/stringLiteral.ts
+function stringLiteral(literal) {
+  const schemaCreator = createIdentitySchemaCreator(
+    SchemaType.STRING_LITERAL,
+    (value, { breadcrumbsPrefix = [] } = {}) => {
+      if (value === literal) {
+        return {
+          ok: true,
+          value: literal
+        };
+      } else {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: breadcrumbsPrefix,
+              message: getErrorMessageForIncorrectType(value, `"${literal}"`)
+            }
+          ]
+        };
+      }
+    }
+  );
+  return schemaCreator();
+}
+
+// src/core/schemas/builders/literals/booleanLiteral.ts
+function booleanLiteral(literal) {
+  const schemaCreator = createIdentitySchemaCreator(
+    SchemaType.BOOLEAN_LITERAL,
+    (value, { breadcrumbsPrefix = [] } = {}) => {
+      if (value === literal) {
+        return {
+          ok: true,
+          value: literal
+        };
+      } else {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: breadcrumbsPrefix,
+              message: getErrorMessageForIncorrectType(value, `${literal.toString()}`)
+            }
+          ]
+        };
+      }
+    }
+  );
+  return schemaCreator();
+}
+
+// src/core/schemas/builders/primitives/any.ts
+var any = createIdentitySchemaCreator(SchemaType.ANY, (value) => ({ ok: true, value }));
+
+// src/core/schemas/builders/primitives/boolean.ts
+var boolean = createIdentitySchemaCreator(
+  SchemaType.BOOLEAN,
+  (value, { breadcrumbsPrefix = [] } = {}) => {
+    if (typeof value === "boolean") {
+      return {
+        ok: true,
+        value
+      };
+    } else {
+      return {
+        ok: false,
+        errors: [
+          {
+            path: breadcrumbsPrefix,
+            message: getErrorMessageForIncorrectType(value, "boolean")
+          }
+        ]
+      };
+    }
+  }
+);
+
+// src/core/schemas/builders/primitives/number.ts
+var number = createIdentitySchemaCreator(
+  SchemaType.NUMBER,
+  (value, { breadcrumbsPrefix = [] } = {}) => {
+    if (typeof value === "number") {
+      return {
+        ok: true,
+        value
+      };
+    } else {
+      return {
+        ok: false,
+        errors: [
+          {
+            path: breadcrumbsPrefix,
+            message: getErrorMessageForIncorrectType(value, "number")
+          }
+        ]
+      };
+    }
+  }
+);
+
+// src/core/schemas/builders/primitives/string.ts
+var string = createIdentitySchemaCreator(
+  SchemaType.STRING,
+  (value, { breadcrumbsPrefix = [] } = {}) => {
+    if (typeof value === "string") {
+      return {
+        ok: true,
+        value
+      };
+    } else {
+      return {
+        ok: false,
+        errors: [
+          {
+            path: breadcrumbsPrefix,
+            message: getErrorMessageForIncorrectType(value, "string")
+          }
+        ]
+      };
+    }
+  }
+);
+
+// src/core/schemas/builders/primitives/unknown.ts
+var unknown = createIdentitySchemaCreator(SchemaType.UNKNOWN, (value) => ({ ok: true, value }));
+
+// src/core/schemas/builders/record/record.ts
+function record(keySchema, valueSchema) {
+  const baseSchema = {
+    parse: (raw, opts) => {
+      return validateAndTransformRecord({
+        value: raw,
+        isKeyNumeric: keySchema.getType() === SchemaType.NUMBER,
+        transformKey: (key) => keySchema.parse(key, {
+          ...opts,
+          breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], `${key} (key)`]
+        }),
+        transformValue: (value, key) => valueSchema.parse(value, {
+          ...opts,
+          breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], `${key}`]
+        }),
+        breadcrumbsPrefix: opts?.breadcrumbsPrefix
+      });
+    },
+    json: (parsed, opts) => {
+      return validateAndTransformRecord({
+        value: parsed,
+        isKeyNumeric: keySchema.getType() === SchemaType.NUMBER,
+        transformKey: (key) => keySchema.json(key, {
+          ...opts,
+          breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], `${key} (key)`]
+        }),
+        transformValue: (value, key) => valueSchema.json(value, {
+          ...opts,
+          breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], `${key}`]
+        }),
+        breadcrumbsPrefix: opts?.breadcrumbsPrefix
+      });
+    },
+    getType: () => SchemaType.RECORD
+  };
+  return {
+    ...maybeSkipValidation(baseSchema),
+    ...getSchemaUtils(baseSchema)
+  };
+}
+function validateAndTransformRecord({
+  value,
+  isKeyNumeric,
+  transformKey,
+  transformValue,
+  breadcrumbsPrefix = []
+}) {
+  if (!isPlainObject(value)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: breadcrumbsPrefix,
+          message: getErrorMessageForIncorrectType(value, "object")
+        }
+      ]
+    };
+  }
+  return entries(value).reduce(
+    (accPromise, [stringKey, value2]) => {
+      if (value2 === void 0) {
+        return accPromise;
+      }
+      const acc = accPromise;
+      let key = stringKey;
+      if (isKeyNumeric) {
+        const numberKey = stringKey.length > 0 ? Number(stringKey) : NaN;
+        if (!isNaN(numberKey)) {
+          key = numberKey;
+        }
+      }
+      const transformedKey = transformKey(key);
+      const transformedValue = transformValue(value2, key);
+      if (acc.ok && transformedKey.ok && transformedValue.ok) {
+        return {
+          ok: true,
+          value: {
+            ...acc.value,
+            [transformedKey.value]: transformedValue.value
+          }
+        };
+      }
+      const errors = [];
+      if (!acc.ok) {
+        errors.push(...acc.errors);
+      }
+      if (!transformedKey.ok) {
+        errors.push(...transformedKey.errors);
+      }
+      if (!transformedValue.ok) {
+        errors.push(...transformedValue.errors);
+      }
+      return {
+        ok: false,
+        errors
+      };
+    },
+    { ok: true, value: {} }
+  );
+}
+
+// src/core/schemas/builders/set/set.ts
+function set(schema) {
+  const listSchema = list(schema);
+  const baseSchema = {
+    parse: (raw, opts) => {
+      const parsedList = listSchema.parse(raw, opts);
+      if (parsedList.ok) {
+        return {
+          ok: true,
+          value: new Set(parsedList.value)
+        };
+      } else {
+        return parsedList;
+      }
+    },
+    json: (parsed, opts) => {
+      if (!(parsed instanceof Set)) {
+        return {
+          ok: false,
+          errors: [
+            {
+              path: opts?.breadcrumbsPrefix ?? [],
+              message: getErrorMessageForIncorrectType(parsed, "Set")
+            }
+          ]
+        };
+      }
+      const jsonList = listSchema.json([...parsed], opts);
+      return jsonList;
+    },
+    getType: () => SchemaType.SET
+  };
+  return {
+    ...maybeSkipValidation(baseSchema),
+    ...getSchemaUtils(baseSchema)
+  };
+}
+
+// src/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.ts
+function undiscriminatedUnion(schemas) {
+  const baseSchema = {
+    parse: (raw, opts) => {
+      return validateAndTransformUndiscriminatedUnion(
+        (schema, opts2) => schema.parse(raw, opts2),
+        schemas,
+        opts
+      );
+    },
+    json: (parsed, opts) => {
+      return validateAndTransformUndiscriminatedUnion(
+        (schema, opts2) => schema.json(parsed, opts2),
+        schemas,
+        opts
+      );
+    },
+    getType: () => SchemaType.UNDISCRIMINATED_UNION
+  };
+  return {
+    ...maybeSkipValidation(baseSchema),
+    ...getSchemaUtils(baseSchema)
+  };
+}
+function validateAndTransformUndiscriminatedUnion(transform2, schemas, opts) {
+  const errors = [];
+  for (const [index, schema] of schemas.entries()) {
+    const transformed = transform2(schema, { ...opts, skipValidation: false });
+    if (transformed.ok) {
+      return transformed;
+    } else {
+      for (const error of transformed.errors) {
+        errors.push({
+          path: error.path,
+          message: `[Variant ${index}] ${error.message}`
+        });
+      }
+    }
+  }
+  return {
+    ok: false,
+    errors
+  };
+}
+
+// src/core/schemas/builders/union/discriminant.ts
+function discriminant(parsedDiscriminant, rawDiscriminant) {
+  return {
+    parsedDiscriminant,
+    rawDiscriminant
+  };
+}
+
+// src/core/schemas/builders/union/union.ts
+function union(discriminant2, union2) {
+  const rawDiscriminant = typeof discriminant2 === "string" ? discriminant2 : discriminant2.rawDiscriminant;
+  const parsedDiscriminant = typeof discriminant2 === "string" ? discriminant2 : discriminant2.parsedDiscriminant;
+  const discriminantValueSchema = enum_(keys(union2));
+  const baseSchema = {
+    parse: (raw, opts) => {
+      return transformAndValidateUnion({
+        value: raw,
+        discriminant: rawDiscriminant,
+        transformedDiscriminant: parsedDiscriminant,
+        transformDiscriminantValue: (discriminantValue) => discriminantValueSchema.parse(discriminantValue, {
+          allowUnrecognizedEnumValues: opts?.allowUnrecognizedUnionMembers,
+          breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], rawDiscriminant]
+        }),
+        getAdditionalPropertiesSchema: (discriminantValue) => union2[discriminantValue],
+        allowUnrecognizedUnionMembers: opts?.allowUnrecognizedUnionMembers,
+        transformAdditionalProperties: (additionalProperties, additionalPropertiesSchema) => additionalPropertiesSchema.parse(additionalProperties, opts),
+        breadcrumbsPrefix: opts?.breadcrumbsPrefix
+      });
+    },
+    json: (parsed, opts) => {
+      return transformAndValidateUnion({
+        value: parsed,
+        discriminant: parsedDiscriminant,
+        transformedDiscriminant: rawDiscriminant,
+        transformDiscriminantValue: (discriminantValue) => discriminantValueSchema.json(discriminantValue, {
+          allowUnrecognizedEnumValues: opts?.allowUnrecognizedUnionMembers,
+          breadcrumbsPrefix: [...opts?.breadcrumbsPrefix ?? [], parsedDiscriminant]
+        }),
+        getAdditionalPropertiesSchema: (discriminantValue) => union2[discriminantValue],
+        allowUnrecognizedUnionMembers: opts?.allowUnrecognizedUnionMembers,
+        transformAdditionalProperties: (additionalProperties, additionalPropertiesSchema) => additionalPropertiesSchema.json(additionalProperties, opts),
+        breadcrumbsPrefix: opts?.breadcrumbsPrefix
+      });
+    },
+    getType: () => SchemaType.UNION
+  };
+  return {
+    ...maybeSkipValidation(baseSchema),
+    ...getSchemaUtils(baseSchema),
+    ...getObjectLikeUtils(baseSchema)
+  };
+}
+function transformAndValidateUnion({
+  value,
+  discriminant: discriminant2,
+  transformedDiscriminant,
+  transformDiscriminantValue,
+  getAdditionalPropertiesSchema,
+  allowUnrecognizedUnionMembers = false,
+  transformAdditionalProperties,
+  breadcrumbsPrefix = []
+}) {
+  if (!isPlainObject(value)) {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: breadcrumbsPrefix,
+          message: getErrorMessageForIncorrectType(value, "object")
+        }
+      ]
+    };
+  }
+  const { [discriminant2]: discriminantValue, ...additionalProperties } = value;
+  if (discriminantValue == null) {
+    return {
+      ok: false,
+      errors: [
+        {
+          path: breadcrumbsPrefix,
+          message: `Missing discriminant ("${discriminant2}")`
+        }
+      ]
+    };
+  }
+  const transformedDiscriminantValue = transformDiscriminantValue(discriminantValue);
+  if (!transformedDiscriminantValue.ok) {
+    return {
+      ok: false,
+      errors: transformedDiscriminantValue.errors
+    };
+  }
+  const additionalPropertiesSchema = getAdditionalPropertiesSchema(transformedDiscriminantValue.value);
+  if (additionalPropertiesSchema == null) {
+    if (allowUnrecognizedUnionMembers) {
+      return {
+        ok: true,
+        value: {
+          [transformedDiscriminant]: transformedDiscriminantValue.value,
+          ...additionalProperties
+        }
+      };
+    } else {
+      return {
+        ok: false,
+        errors: [
+          {
+            path: [...breadcrumbsPrefix, discriminant2],
+            message: "Unexpected discriminant value"
+          }
+        ]
+      };
+    }
+  }
+  const transformedAdditionalProperties = transformAdditionalProperties(
+    additionalProperties,
+    additionalPropertiesSchema
+  );
+  if (!transformedAdditionalProperties.ok) {
+    return transformedAdditionalProperties;
+  }
+  return {
+    ok: true,
+    value: {
+      [transformedDiscriminant]: discriminantValue,
+      ...transformedAdditionalProperties.value
+    }
+  };
+}
+
+// src/serialization/types/RivetId.ts
+var RivetId = schemas_exports.string();
+
+// src/serialization/types/CrashPolicy.ts
+var CrashPolicy = schemas_exports.enum_(["restart", "sleep", "destroy"]);
+
+// src/serialization/types/Actor.ts
+var Actor = schemas_exports.object({
+  actorId: schemas_exports.property("actor_id", RivetId),
+  connectableTs: schemas_exports.property("connectable_ts", schemas_exports.number().optional()),
+  crashPolicy: schemas_exports.property("crash_policy", CrashPolicy),
+  createTs: schemas_exports.property("create_ts", schemas_exports.number()),
+  datacenter: schemas_exports.string(),
+  destroyTs: schemas_exports.property("destroy_ts", schemas_exports.number().optional()),
+  key: schemas_exports.string().optional(),
+  name: schemas_exports.string(),
+  namespaceId: schemas_exports.property("namespace_id", RivetId),
+  pendingAllocationTs: schemas_exports.property("pending_allocation_ts", schemas_exports.number().optional()),
+  runnerNameSelector: schemas_exports.property("runner_name_selector", schemas_exports.string()),
+  sleepTs: schemas_exports.property("sleep_ts", schemas_exports.number().optional()),
+  startTs: schemas_exports.property("start_ts", schemas_exports.number().optional())
+});
+
+// src/serialization/types/ActorName.ts
+var ActorName = schemas_exports.object({
+  metadata: schemas_exports.record(schemas_exports.string(), schemas_exports.unknown())
+});
+
+// src/serialization/types/ActorsCreateResponse.ts
+var ActorsCreateResponse = schemas_exports.object({
+  actor: Actor
+});
+
+// src/serialization/types/ActorsDeleteResponse.ts
+var ActorsDeleteResponse = schemas_exports.record(schemas_exports.string(), schemas_exports.unknown());
+
+// src/serialization/types/ActorsGetByIdResponse.ts
+var ActorsGetByIdResponse = schemas_exports.object({
+  actorId: schemas_exports.property("actor_id", RivetId.optional())
+});
+
+// src/serialization/types/ActorsGetOrCreateByIdResponse.ts
+var ActorsGetOrCreateByIdResponse = schemas_exports.object({
+  actorId: schemas_exports.property("actor_id", RivetId),
+  created: schemas_exports.boolean()
+});
+
+// src/serialization/types/ActorsGetOrCreateResponse.ts
+var ActorsGetOrCreateResponse = schemas_exports.object({
+  actor: Actor,
+  created: schemas_exports.boolean()
+});
+
+// src/serialization/types/ActorsGetResponse.ts
+var ActorsGetResponse = schemas_exports.object({
+  actor: Actor
+});
+
+// src/serialization/types/Pagination.ts
+var Pagination = schemas_exports.object({
+  cursor: schemas_exports.string().optional()
+});
+
+// src/serialization/types/ActorsListNamesResponse.ts
+var ActorsListNamesResponse = schemas_exports.object({
+  names: schemas_exports.record(schemas_exports.string(), ActorName),
+  pagination: Pagination
+});
+
+// src/serialization/types/ActorsListResponse.ts
+var ActorsListResponse = schemas_exports.object({
+  actors: schemas_exports.list(Actor),
+  pagination: Pagination
+});
+
+// src/serialization/types/Datacenter.ts
+var Datacenter = schemas_exports.object({
+  datacenterLabel: schemas_exports.property("datacenter_label", schemas_exports.number()),
+  name: schemas_exports.string(),
+  url: schemas_exports.string()
+});
+
+// src/serialization/types/DatacentersListResponse.ts
+var DatacentersListResponse = schemas_exports.object({
+  datacenters: schemas_exports.list(Datacenter),
+  pagination: Pagination
+});
+
+// src/serialization/types/Namespace.ts
+var Namespace = schemas_exports.object({
+  createTs: schemas_exports.property("create_ts", schemas_exports.number()),
+  displayName: schemas_exports.property("display_name", schemas_exports.string()),
+  name: schemas_exports.string(),
+  namespaceId: schemas_exports.property("namespace_id", RivetId)
+});
+
+// src/serialization/types/NamespacesCreateResponse.ts
+var NamespacesCreateResponse = schemas_exports.object({
+  namespace: Namespace
+});
+
+// src/serialization/types/NamespacesGetResponse.ts
+var NamespacesGetResponse = schemas_exports.object({
+  namespace: Namespace
+});
+
+// src/serialization/types/NamespacesListResponse.ts
+var NamespacesListResponse = schemas_exports.object({
+  namespaces: schemas_exports.list(Namespace),
+  pagination: Pagination
+});
+
+// src/serialization/types/StringHttpAddressHashableMapValue.ts
+var StringHttpAddressHashableMapValue = schemas_exports.object({
+  hostname: schemas_exports.string(),
+  port: schemas_exports.number()
+});
+
+// src/serialization/types/StringHttpAddressHashableMap.ts
+var StringHttpAddressHashableMap = schemas_exports.record(schemas_exports.string(), StringHttpAddressHashableMapValue);
+
+// src/serialization/types/StringTcpAddressHashableMapValue.ts
+var StringTcpAddressHashableMapValue = schemas_exports.object({
+  hostname: schemas_exports.string(),
+  port: schemas_exports.number()
+});
+
+// src/serialization/types/StringTcpAddressHashableMap.ts
+var StringTcpAddressHashableMap = schemas_exports.record(schemas_exports.string(), StringTcpAddressHashableMapValue);
+
+// src/serialization/types/StringUdpAddressHashableMapValue.ts
+var StringUdpAddressHashableMapValue = schemas_exports.object({
+  hostname: schemas_exports.string(),
+  port: schemas_exports.number()
+});
+
+// src/serialization/types/StringUdpAddressHashableMap.ts
+var StringUdpAddressHashableMap = schemas_exports.record(schemas_exports.string(), StringUdpAddressHashableMapValue);
+
+// src/serialization/types/Runner.ts
+var Runner = schemas_exports.object({
+  addressesHttp: schemas_exports.property("addresses_http", StringHttpAddressHashableMap),
+  addressesTcp: schemas_exports.property("addresses_tcp", StringTcpAddressHashableMap),
+  addressesUdp: schemas_exports.property("addresses_udp", StringUdpAddressHashableMap),
+  createTs: schemas_exports.property("create_ts", schemas_exports.number()),
+  datacenter: schemas_exports.string(),
+  drainTs: schemas_exports.property("drain_ts", schemas_exports.number().optional()),
+  key: schemas_exports.string(),
+  lastConnectedTs: schemas_exports.property("last_connected_ts", schemas_exports.number().optional()),
+  lastPingTs: schemas_exports.property("last_ping_ts", schemas_exports.number()),
+  lastRtt: schemas_exports.property("last_rtt", schemas_exports.number()),
+  metadata: schemas_exports.record(schemas_exports.string(), schemas_exports.unknown()).optional(),
+  name: schemas_exports.string(),
+  namespaceId: schemas_exports.property("namespace_id", RivetId),
+  remainingSlots: schemas_exports.property("remaining_slots", schemas_exports.number()),
+  runnerId: schemas_exports.property("runner_id", RivetId),
+  stopTs: schemas_exports.property("stop_ts", schemas_exports.number().optional()),
+  totalSlots: schemas_exports.property("total_slots", schemas_exports.number()),
+  version: schemas_exports.number()
+});
+
+// src/serialization/types/RunnersGetResponse.ts
+var RunnersGetResponse = schemas_exports.object({
+  runner: Runner
+});
+
+// src/serialization/types/RunnersListNamesResponse.ts
+var RunnersListNamesResponse = schemas_exports.object({
+  names: schemas_exports.list(schemas_exports.string()),
+  pagination: Pagination
+});
+
+// src/serialization/types/RunnersListResponse.ts
+var RunnersListResponse = schemas_exports.object({
+  pagination: Pagination,
+  runners: schemas_exports.list(Runner)
+});
+
+// src/serialization/client/requests/ActorsCreateRequest.ts
+var ActorsCreateRequest = schemas_exports.object({
+  crashPolicy: schemas_exports.property("crash_policy", CrashPolicy),
+  input: schemas_exports.string().optional(),
+  key: schemas_exports.string().optional(),
+  name: schemas_exports.string(),
+  runnerNameSelector: schemas_exports.property("runner_name_selector", schemas_exports.string())
+});
+
+// src/serialization/client/requests/ActorsGetOrCreateRequest.ts
+var ActorsGetOrCreateRequest = schemas_exports.object({
+  crashPolicy: schemas_exports.property("crash_policy", CrashPolicy),
+  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/ActorsGetOrCreateByIdRequest.ts
+var ActorsGetOrCreateByIdRequest = schemas_exports.object({
+  crashPolicy: schemas_exports.property("crash_policy", CrashPolicy),
+  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/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()
+});