@rivetkit/engine-api-full 2.0.4-rc.1

package/types/core/schemas/builders/object/types.d.ts

@@ -0,0 +1,31 @@
+import { BaseSchema, Schema, inferParsed, inferRaw } from "../../Schema";
+import { addQuestionMarksToNullableProperties } from "../../utils/addQuestionMarksToNullableProperties";
+import { ObjectLikeUtils } from "../object-like";
+import { SchemaUtils } from "../schema-utils";
+import { Property } from "./property";
+export type ObjectSchema<Raw, Parsed> = BaseObjectSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed> & ObjectUtils<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
+export interface BaseObjectSchema<Raw, Parsed> extends BaseSchema<Raw, Parsed> {
+    _getRawProperties: () => (keyof Raw)[];
+    _getParsedProperties: () => (keyof Parsed)[];
+}
+export interface ObjectUtils<Raw, Parsed> {
+    extend: <RawExtension, ParsedExtension>(schemas: ObjectSchema<RawExtension, ParsedExtension>) => ObjectSchema<Raw & RawExtension, Parsed & ParsedExtension>;
+    passthrough: () => ObjectSchema<Raw & {
+        [key: string]: unknown;
+    }, Parsed & {
+        [key: string]: unknown;
+    }>;
+}
+export type inferRawObject<O extends ObjectSchema<any, any>> = O extends ObjectSchema<infer Raw, any> ? Raw : never;
+export type inferParsedObject<O extends ObjectSchema<any, any>> = O extends ObjectSchema<any, infer Parsed> ? Parsed : never;
+export type inferObjectSchemaFromPropertySchemas<T extends PropertySchemas<keyof T>> = ObjectSchema<inferRawObjectFromPropertySchemas<T>, inferParsedObjectFromPropertySchemas<T>>;
+export type inferRawObjectFromPropertySchemas<T extends PropertySchemas<keyof T>> = addQuestionMarksToNullableProperties<{
+    [ParsedKey in keyof T as inferRawKey<ParsedKey, T[ParsedKey]>]: inferRawPropertySchema<T[ParsedKey]>;
+}>;
+export type inferParsedObjectFromPropertySchemas<T extends PropertySchemas<keyof T>> = addQuestionMarksToNullableProperties<{
+    [K in keyof T]: inferParsedPropertySchema<T[K]>;
+}>;
+export type PropertySchemas<ParsedKeys extends string | number | symbol> = Record<ParsedKeys, Property<any, any, any> | Schema<any, any>>;
+export type inferRawPropertySchema<P extends Property<any, any, any> | Schema<any, any>> = P extends Property<any, infer Raw, any> ? Raw : P extends Schema<any, any> ? inferRaw<P> : never;
+export type inferParsedPropertySchema<P extends Property<any, any, any> | Schema<any, any>> = P extends Property<any, any, infer Parsed> ? Parsed : P extends Schema<any, any> ? inferParsed<P> : never;
+export type inferRawKey<ParsedKey extends string | number | symbol, P extends Property<any, any, any> | Schema<any, any>> = P extends Property<infer Raw, any, any> ? Raw : ParsedKey;

package/types/core/schemas/builders/object-like/getObjectLikeUtils.d.ts

@@ -0,0 +1,9 @@
+import { BaseSchema } from "../../Schema";
+import { ObjectLikeSchema, ObjectLikeUtils } from "./types";
+export declare function getObjectLikeUtils<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): ObjectLikeUtils<Raw, Parsed>;
+/**
+ * object-like utils are defined in one file to resolve issues with circular imports
+ */
+export declare function withParsedProperties<RawObjectShape, ParsedObjectShape, Properties>(objectLike: BaseSchema<RawObjectShape, ParsedObjectShape>, properties: {
+    [K in keyof Properties]: Properties[K] | ((parsed: ParsedObjectShape) => Properties[K]);
+}): ObjectLikeSchema<RawObjectShape, ParsedObjectShape & Properties>;

package/types/core/schemas/builders/object-like/index.d.ts

@@ -0,0 +1,2 @@
+export { getObjectLikeUtils, withParsedProperties } from "./getObjectLikeUtils";
+export type { ObjectLikeSchema, ObjectLikeUtils } from "./types";

package/types/core/schemas/builders/object-like/types.d.ts

@@ -0,0 +1,7 @@
+import { BaseSchema, Schema } from "../../Schema";
+export type ObjectLikeSchema<Raw, Parsed> = Schema<Raw, Parsed> & BaseSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed>;
+export interface ObjectLikeUtils<Raw, Parsed> {
+    withParsedProperties: <T extends Record<string, any>>(properties: {
+        [K in keyof T]: T[K] | ((parsed: Parsed) => T[K]);
+    }) => ObjectLikeSchema<Raw, Parsed & T>;
+}

package/types/core/schemas/builders/primitives/any.d.ts

@@ -0,0 +1 @@
+export declare const any: () => import("../../Schema").Schema<any, any>;

package/types/core/schemas/builders/primitives/boolean.d.ts

@@ -0,0 +1 @@
+export declare const boolean: () => import("../../Schema").Schema<boolean, boolean>;

package/types/core/schemas/builders/primitives/index.d.ts

@@ -0,0 +1,5 @@
+export { any } from "./any";
+export { boolean } from "./boolean";
+export { number } from "./number";
+export { string } from "./string";
+export { unknown } from "./unknown";

package/types/core/schemas/builders/primitives/number.d.ts

@@ -0,0 +1 @@
+export declare const number: () => import("../../Schema").Schema<number, number>;

package/types/core/schemas/builders/primitives/string.d.ts

@@ -0,0 +1 @@
+export declare const string: () => import("../../Schema").Schema<string, string>;

package/types/core/schemas/builders/primitives/unknown.d.ts

@@ -0,0 +1 @@
+export declare const unknown: () => import("../../Schema").Schema<unknown, unknown>;

package/types/core/schemas/builders/record/index.d.ts

@@ -0,0 +1,2 @@
+export { record } from "./record";
+export type { BaseRecordSchema, RecordSchema } from "./types";

package/types/core/schemas/builders/record/record.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from "../../Schema";
+import { RecordSchema } from "./types";
+export declare function record<RawKey extends string | number, RawValue, ParsedValue, ParsedKey extends string | number>(keySchema: Schema<RawKey, ParsedKey>, valueSchema: Schema<RawValue, ParsedValue>): RecordSchema<RawKey, RawValue, ParsedKey, ParsedValue>;

package/types/core/schemas/builders/record/types.d.ts

@@ -0,0 +1,4 @@
+import { BaseSchema } from "../../Schema";
+import { SchemaUtils } from "../schema-utils";
+export type RecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseRecordSchema<RawKey, RawValue, ParsedKey, ParsedValue> & SchemaUtils<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;
+export type BaseRecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseSchema<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;

package/types/core/schemas/builders/schema-utils/JsonError.d.ts

@@ -0,0 +1,5 @@
+import { ValidationError } from "../../Schema";
+export declare class JsonError extends Error {
+    readonly errors: ValidationError[];
+    constructor(errors: ValidationError[]);
+}

package/types/core/schemas/builders/schema-utils/ParseError.d.ts

@@ -0,0 +1,5 @@
+import { ValidationError } from "../../Schema";
+export declare class ParseError extends Error {
+    readonly errors: ValidationError[];
+    constructor(errors: ValidationError[]);
+}

package/types/core/schemas/builders/schema-utils/getSchemaUtils.d.ts

@@ -0,0 +1,21 @@
+import { BaseSchema, Schema, SchemaOptions } from "../../Schema";
+export interface SchemaUtils<Raw, Parsed> {
+    nullable: () => Schema<Raw | null, Parsed | null>;
+    optional: () => Schema<Raw | null | undefined, Parsed | undefined>;
+    optionalNullable: () => Schema<Raw | null | undefined, Parsed | null | undefined>;
+    transform: <Transformed>(transformer: SchemaTransformer<Parsed, Transformed>) => Schema<Raw, Transformed>;
+    parseOrThrow: (raw: unknown, opts?: SchemaOptions) => Parsed;
+    jsonOrThrow: (raw: unknown, opts?: SchemaOptions) => Raw;
+}
+export interface SchemaTransformer<Parsed, Transformed> {
+    transform: (parsed: Parsed) => Transformed;
+    untransform: (transformed: any) => Parsed;
+}
+export declare function getSchemaUtils<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): SchemaUtils<Raw, Parsed>;
+/**
+ * schema utils are defined in one file to resolve issues with circular imports
+ */
+export declare function nullable<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): Schema<Raw | null, Parsed | null>;
+export declare function optional<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): Schema<Raw | null | undefined, Parsed | undefined>;
+export declare function optionalNullable<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): Schema<Raw | null | undefined, Parsed | null | undefined>;
+export declare function transform<Raw, Parsed, Transformed>(schema: BaseSchema<Raw, Parsed>, transformer: SchemaTransformer<Parsed, Transformed>): Schema<Raw, Transformed>;

package/types/core/schemas/builders/schema-utils/index.d.ts

@@ -0,0 +1,4 @@
+export { getSchemaUtils, optional, transform } from "./getSchemaUtils";
+export type { SchemaUtils } from "./getSchemaUtils";
+export { JsonError } from "./JsonError";
+export { ParseError } from "./ParseError";

package/types/core/schemas/builders/schema-utils/stringifyValidationErrors.d.ts

@@ -0,0 +1,2 @@
+import { ValidationError } from "../../Schema";
+export declare function stringifyValidationError(error: ValidationError): string;

package/types/core/schemas/builders/set/index.d.ts

@@ -0,0 +1 @@
+export { set } from "./set";

package/types/core/schemas/builders/set/set.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from "../../Schema";
+export declare function set<Raw, Parsed>(schema: Schema<Raw, Parsed>): Schema<Raw[], Set<Parsed>>;

package/types/core/schemas/builders/undiscriminated-union/index.d.ts

@@ -0,0 +1,2 @@
+export type { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema, UndiscriminatedUnionSchema, } from "./types";
+export { undiscriminatedUnion } from "./undiscriminatedUnion";

package/types/core/schemas/builders/undiscriminated-union/types.d.ts

@@ -0,0 +1,4 @@
+import { Schema, inferParsed, inferRaw } from "../../Schema";
+export type UndiscriminatedUnionSchema<Schemas extends [...Schema[]]> = Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;
+export type inferRawUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferRaw<Schemas[number]>;
+export type inferParsedUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferParsed<Schemas[number]>;

package/types/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from "../../Schema";
+import { inferParsedUnidiscriminatedUnionSchema, inferRawUnidiscriminatedUnionSchema } from "./types";
+export declare function undiscriminatedUnion<Schemas extends [Schema<any, any>, ...Schema<any, any>[]]>(schemas: Schemas): Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;

package/types/core/schemas/builders/union/discriminant.d.ts

@@ -0,0 +1,5 @@
+export declare function discriminant<RawDiscriminant extends string, ParsedDiscriminant extends string>(parsedDiscriminant: ParsedDiscriminant, rawDiscriminant: RawDiscriminant): Discriminant<RawDiscriminant, ParsedDiscriminant>;
+export interface Discriminant<RawDiscriminant extends string, ParsedDiscriminant extends string> {
+    parsedDiscriminant: ParsedDiscriminant;
+    rawDiscriminant: RawDiscriminant;
+}

package/types/core/schemas/builders/union/index.d.ts

@@ -0,0 +1,4 @@
+export { discriminant } from "./discriminant";
+export type { Discriminant } from "./discriminant";
+export type { inferParsedDiscriminant, inferParsedUnion, inferRawDiscriminant, inferRawUnion, UnionSubtypes, } from "./types";
+export { union } from "./union";

package/types/core/schemas/builders/union/types.d.ts

@@ -0,0 +1,13 @@
+import { ObjectSchema, inferParsedObject, inferRawObject } from "../object";
+import { Discriminant } from "./discriminant";
+export type UnionSubtypes<DiscriminantValues extends string | number | symbol> = {
+    [K in DiscriminantValues]: ObjectSchema<any, any>;
+};
+export type inferRawUnion<D extends string | Discriminant<any, any>, U extends UnionSubtypes<keyof U>> = {
+    [K in keyof U]: Record<inferRawDiscriminant<D>, K> & inferRawObject<U[K]>;
+}[keyof U];
+export type inferParsedUnion<D extends string | Discriminant<any, any>, U extends UnionSubtypes<keyof U>> = {
+    [K in keyof U]: Record<inferParsedDiscriminant<D>, K> & inferParsedObject<U[K]>;
+}[keyof U];
+export type inferRawDiscriminant<D extends string | Discriminant<any, any>> = D extends string ? D : D extends Discriminant<infer Raw, any> ? Raw : never;
+export type inferParsedDiscriminant<D extends string | Discriminant<any, any>> = D extends string ? D : D extends Discriminant<any, infer Parsed> ? Parsed : never;

package/types/core/schemas/builders/union/union.d.ts

@@ -0,0 +1,4 @@
+import { ObjectLikeSchema } from "../object-like";
+import { Discriminant } from "./discriminant";
+import { UnionSubtypes, inferParsedUnion, inferRawUnion } from "./types";
+export declare function union<D extends string | Discriminant<any, any>, U extends UnionSubtypes<any>>(discriminant: D, union: U): ObjectLikeSchema<inferRawUnion<D, U>, inferParsedUnion<D, U>>;

package/types/core/schemas/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./builders";
+export type { inferParsed, inferRaw, Schema, SchemaOptions } from "./Schema";

package/types/core/schemas/utils/MaybePromise.d.ts

@@ -0,0 +1 @@
+export type MaybePromise<T> = T | Promise<T>;

package/types/core/schemas/utils/addQuestionMarksToNullableProperties.d.ts

@@ -0,0 +1,7 @@
+export type addQuestionMarksToNullableProperties<T> = {
+    [K in OptionalKeys<T>]?: T[K];
+} & Pick<T, RequiredKeys<T>>;
+export type OptionalKeys<T> = {
+    [K in keyof T]-?: undefined extends T[K] ? K : never;
+}[keyof T];
+export type RequiredKeys<T> = Exclude<keyof T, OptionalKeys<T>>;

package/types/core/schemas/utils/createIdentitySchemaCreator.d.ts

@@ -0,0 +1,2 @@
+import { MaybeValid, Schema, SchemaOptions, SchemaType } from "../Schema";
+export declare function createIdentitySchemaCreator<T>(schemaType: SchemaType, validate: (value: unknown, opts?: SchemaOptions) => MaybeValid<T>): () => Schema<T, T>;

package/types/core/schemas/utils/entries.d.ts

@@ -0,0 +1 @@
+export declare function entries<T extends object>(object: T): [keyof T, T[keyof T]][];

package/types/core/schemas/utils/filterObject.d.ts

@@ -0,0 +1 @@
+export declare function filterObject<T extends object, K extends keyof T>(obj: T, keysToInclude: K[]): Pick<T, K>;

package/types/core/schemas/utils/getErrorMessageForIncorrectType.d.ts

@@ -0,0 +1 @@
+export declare function getErrorMessageForIncorrectType(value: unknown, expectedType: string): string;

package/types/core/schemas/utils/isPlainObject.d.ts

@@ -0,0 +1 @@
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;

package/types/core/schemas/utils/keys.d.ts

@@ -0,0 +1 @@
+export declare function keys<T extends object>(object: T): (keyof T)[];

package/types/core/schemas/utils/maybeSkipValidation.d.ts

@@ -0,0 +1,2 @@
+import { BaseSchema } from "../Schema";
+export declare function maybeSkipValidation<S extends BaseSchema<Raw, Parsed>, Raw, Parsed>(schema: S): S;

package/types/core/schemas/utils/partition.d.ts

@@ -0,0 +1 @@
+export declare function partition<T>(items: readonly T[], predicate: (item: T) => boolean): [T[], T[]];

package/types/errors/RivetError.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+export declare class RivetError extends Error {
+    readonly statusCode?: number;
+    readonly body?: unknown;
+    constructor({ message, statusCode, body }: {
+        message?: string;
+        statusCode?: number;
+        body?: unknown;
+    });
+}

package/types/errors/RivetTimeoutError.d.ts

@@ -0,0 +1,6 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+export declare class RivetTimeoutError extends Error {
+    constructor(message: string);
+}

package/types/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { RivetError } from "./RivetError";
+export { RivetTimeoutError } from "./RivetTimeoutError";

package/types/index.d.ts

@@ -0,0 +1,4 @@
+export * as Rivet from "./api";
+export { RivetClient } from "./Client";
+export { RivetError, RivetTimeoutError } from "./errors";
+export * as serialization from "./serialization";

package/types/serialization/client/index.d.ts

@@ -0,0 +1 @@
+export * from "./requests";

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

@@ -0,0 +1,18 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../../index";
+import * as Rivet from "../../../api/index";
+import * as core from "../../../core";
+import { CrashPolicy } from "../../types/CrashPolicy";
+export declare const ActorsCreateRequest: core.serialization.Schema<serializers.ActorsCreateRequest.Raw, Omit<Rivet.ActorsCreateRequest, "namespace">>;
+export declare namespace ActorsCreateRequest {
+    interface Raw {
+        crash_policy: CrashPolicy.Raw;
+        datacenter?: string | null;
+        input?: string | null;
+        key?: string | null;
+        name: string;
+        runner_name_selector: string;
+    }
+}

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

@@ -0,0 +1,18 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../../index";
+import * as Rivet from "../../../api/index";
+import * as core from "../../../core";
+import { CrashPolicy } from "../../types/CrashPolicy";
+export declare const ActorsGetOrCreateRequest: core.serialization.Schema<serializers.ActorsGetOrCreateRequest.Raw, Omit<Rivet.ActorsGetOrCreateRequest, "namespace">>;
+export declare namespace ActorsGetOrCreateRequest {
+    interface Raw {
+        crash_policy: CrashPolicy.Raw;
+        datacenter?: string | null;
+        input?: string | null;
+        key: string;
+        name: string;
+        runner_name_selector: string;
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../../index";
+import * as Rivet from "../../../api/index";
+import * as core from "../../../core";
+export declare const RunnerConfigsServerlessHealthCheckRequest: core.serialization.Schema<serializers.RunnerConfigsServerlessHealthCheckRequest.Raw, Omit<Rivet.RunnerConfigsServerlessHealthCheckRequest, "namespace">>;
+export declare namespace RunnerConfigsServerlessHealthCheckRequest {
+    interface Raw {
+        headers?: Record<string, string> | null;
+        url: string;
+    }
+}

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

@@ -0,0 +1,13 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../../index";
+import * as Rivet from "../../../api/index";
+import * as core from "../../../core";
+import { RunnerConfig } from "../../types/RunnerConfig";
+export declare const RunnerConfigsUpsertRequestBody: core.serialization.Schema<serializers.RunnerConfigsUpsertRequestBody.Raw, Omit<Rivet.RunnerConfigsUpsertRequestBody, "namespace">>;
+export declare namespace RunnerConfigsUpsertRequestBody {
+    interface Raw {
+        datacenters: Record<string, RunnerConfig.Raw>;
+    }
+}

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

@@ -0,0 +1,4 @@
+export { ActorsCreateRequest } from "./ActorsCreateRequest";
+export { ActorsGetOrCreateRequest } from "./ActorsGetOrCreateRequest";
+export { RunnerConfigsServerlessHealthCheckRequest } from "./RunnerConfigsServerlessHealthCheckRequest";
+export { RunnerConfigsUpsertRequestBody } from "./RunnerConfigsUpsertRequestBody";

package/types/serialization/index.d.ts

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

package/types/serialization/resources/index.d.ts

@@ -0,0 +1,2 @@
+export * as namespaces from "./namespaces";
+export * from "./namespaces/client/requests";

package/types/serialization/resources/namespaces/client/index.d.ts

@@ -0,0 +1 @@
+export * from "./requests";

package/types/serialization/resources/namespaces/client/requests/NamespacesCreateRequest.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../../../../index";
+import * as Rivet from "../../../../../api/index";
+import * as core from "../../../../../core";
+export declare const NamespacesCreateRequest: core.serialization.Schema<serializers.NamespacesCreateRequest.Raw, Rivet.NamespacesCreateRequest>;
+export declare namespace NamespacesCreateRequest {
+    interface Raw {
+        display_name: string;
+        name: string;
+    }
+}

package/types/serialization/resources/namespaces/client/requests/index.d.ts

@@ -0,0 +1 @@
+export { NamespacesCreateRequest } from "./NamespacesCreateRequest";

package/types/serialization/resources/namespaces/index.d.ts

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

package/types/serialization/types/Actor.d.ts

@@ -0,0 +1,28 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../index";
+import * as Rivet from "../../api/index";
+import * as core from "../../core";
+import { RivetId } from "./RivetId";
+import { CrashPolicy } from "./CrashPolicy";
+export declare const Actor: core.serialization.ObjectSchema<serializers.Actor.Raw, Rivet.Actor>;
+export declare namespace Actor {
+    interface Raw {
+        actor_id: RivetId.Raw;
+        connectable_ts?: number | null;
+        crash_policy: CrashPolicy.Raw;
+        create_ts: number;
+        datacenter: string;
+        destroy_ts?: number | null;
+        error?: Record<string, unknown> | null;
+        key?: string | null;
+        name: string;
+        namespace_id: RivetId.Raw;
+        pending_allocation_ts?: number | null;
+        reschedule_ts?: number | null;
+        runner_name_selector: string;
+        sleep_ts?: number | null;
+        start_ts?: number | null;
+    }
+}

package/types/serialization/types/ActorName.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../index";
+import * as Rivet from "../../api/index";
+import * as core from "../../core";
+export declare const ActorName: core.serialization.ObjectSchema<serializers.ActorName.Raw, Rivet.ActorName>;
+export declare namespace ActorName {
+    interface Raw {
+        metadata: Record<string, unknown>;
+    }
+}

package/types/serialization/types/ActorsCreateResponse.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../index";
+import * as Rivet from "../../api/index";
+import * as core from "../../core";
+import { Actor } from "./Actor";
+export declare const ActorsCreateResponse: core.serialization.ObjectSchema<serializers.ActorsCreateResponse.Raw, Rivet.ActorsCreateResponse>;
+export declare namespace ActorsCreateResponse {
+    interface Raw {
+        actor: Actor.Raw;
+    }
+}

package/types/serialization/types/ActorsDeleteResponse.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../index";
+import * as Rivet from "../../api/index";
+import * as core from "../../core";
+export declare const ActorsDeleteResponse: core.serialization.Schema<serializers.ActorsDeleteResponse.Raw, Rivet.ActorsDeleteResponse>;
+export declare namespace ActorsDeleteResponse {
+    type Raw = Record<string, unknown>;
+}

package/types/serialization/types/ActorsGetOrCreateResponse.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../index";
+import * as Rivet from "../../api/index";
+import * as core from "../../core";
+import { Actor } from "./Actor";
+export declare const ActorsGetOrCreateResponse: core.serialization.ObjectSchema<serializers.ActorsGetOrCreateResponse.Raw, Rivet.ActorsGetOrCreateResponse>;
+export declare namespace ActorsGetOrCreateResponse {
+    interface Raw {
+        actor: Actor.Raw;
+        created: boolean;
+    }
+}

package/types/serialization/types/ActorsKvGetResponse.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../index";
+import * as Rivet from "../../api/index";
+import * as core from "../../core";
+export declare const ActorsKvGetResponse: core.serialization.ObjectSchema<serializers.ActorsKvGetResponse.Raw, Rivet.ActorsKvGetResponse>;
+export declare namespace ActorsKvGetResponse {
+    interface Raw {
+        update_ts: number;
+        value: string;
+    }
+}

package/types/serialization/types/ActorsListNamesResponse.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../index";
+import * as Rivet from "../../api/index";
+import * as core from "../../core";
+import { ActorName } from "./ActorName";
+import { Pagination } from "./Pagination";
+export declare const ActorsListNamesResponse: core.serialization.ObjectSchema<serializers.ActorsListNamesResponse.Raw, Rivet.ActorsListNamesResponse>;
+export declare namespace ActorsListNamesResponse {
+    interface Raw {
+        names: Record<string, ActorName.Raw>;
+        pagination: Pagination.Raw;
+    }
+}

package/types/serialization/types/ActorsListResponse.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../index";
+import * as Rivet from "../../api/index";
+import * as core from "../../core";
+import { Actor } from "./Actor";
+import { Pagination } from "./Pagination";
+export declare const ActorsListResponse: core.serialization.ObjectSchema<serializers.ActorsListResponse.Raw, Rivet.ActorsListResponse>;
+export declare namespace ActorsListResponse {
+    interface Raw {
+        actors: Actor.Raw[];
+        pagination: Pagination.Raw;
+    }
+}

package/types/serialization/types/CrashPolicy.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../index";
+import * as Rivet from "../../api/index";
+import * as core from "../../core";
+export declare const CrashPolicy: core.serialization.Schema<serializers.CrashPolicy.Raw, Rivet.CrashPolicy>;
+export declare namespace CrashPolicy {
+    type Raw = "restart" | "sleep" | "destroy";
+}

package/types/serialization/types/Datacenter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../index";
+import * as Rivet from "../../api/index";
+import * as core from "../../core";
+export declare const Datacenter: core.serialization.ObjectSchema<serializers.Datacenter.Raw, Rivet.Datacenter>;
+export declare namespace Datacenter {
+    interface Raw {
+        label: number;
+        name: string;
+        url: string;
+    }
+}

package/types/serialization/types/DatacenterHealth.d.ts

@@ -0,0 +1,19 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../index";
+import * as Rivet from "../../api/index";
+import * as core from "../../core";
+import { HealthResponse } from "./HealthResponse";
+import { HealthStatus } from "./HealthStatus";
+export declare const DatacenterHealth: core.serialization.ObjectSchema<serializers.DatacenterHealth.Raw, Rivet.DatacenterHealth>;
+export declare namespace DatacenterHealth {
+    interface Raw {
+        datacenter_label: number;
+        datacenter_name: string;
+        error?: string | null;
+        response?: HealthResponse.Raw | null;
+        rtt_ms?: number | null;
+        status: HealthStatus.Raw;
+    }
+}

package/types/serialization/types/DatacentersListResponse.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../index";
+import * as Rivet from "../../api/index";
+import * as core from "../../core";
+import { Datacenter } from "./Datacenter";
+import { Pagination } from "./Pagination";
+export declare const DatacentersListResponse: core.serialization.ObjectSchema<serializers.DatacentersListResponse.Raw, Rivet.DatacentersListResponse>;
+export declare namespace DatacentersListResponse {
+    interface Raw {
+        datacenters: Datacenter.Raw[];
+        pagination: Pagination.Raw;
+    }
+}

package/types/serialization/types/HealthFanoutResponse.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This file was auto-generated by Fern from our API Definition.
+ */
+import * as serializers from "../index";
+import * as Rivet from "../../api/index";
+import * as core from "../../core";
+import { DatacenterHealth } from "./DatacenterHealth";
+export declare const HealthFanoutResponse: core.serialization.ObjectSchema<serializers.HealthFanoutResponse.Raw, Rivet.HealthFanoutResponse>;
+export declare namespace HealthFanoutResponse {
+    interface Raw {
+        datacenters: DatacenterHealth.Raw[];
+    }
+}