@rise-maritime/keelson-js 0.5.3 → 0.6.0-alpha.221.dev.1

package/dist/interfaces/RoutePlanner.d.ts

@@ -0,0 +1,152 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { Coordinate } from "./Coordinate";
+import { Extensions, Route, RouteInfo, RouteRef } from "./Route";
+export declare const protobufPackage = "keelson.interfaces.route_planner";
+/**
+ * What the planner should optimise for. A closed set, not the free-form
+ * string it replaced: a caller choosing a goal needs to know which goals
+ * exist, and an unrecognised label silently falling back to a default cost
+ * profile is the failure mode this prevents.
+ *
+ * Deployment-specific tunings (a particular trial's conservative profile, a
+ * pilot-matched profile) deliberately do NOT appear here — those are vendor
+ * configuration, and belong in `extensions` rather than in a vocabulary every
+ * consumer on the bus inherits.
+ */
+export declare enum OptimizationGoal {
+    /** OPTIMIZATION_GOAL_UNSPECIFIED - planner picks its own default */
+    OPTIMIZATION_GOAL_UNSPECIFIED = 0,
+    OPTIMIZATION_GOAL_SHORTEST = 1,
+    OPTIMIZATION_GOAL_FASTEST = 2,
+    OPTIMIZATION_GOAL_SAFEST = 3,
+    OPTIMIZATION_GOAL_PREFER_FAIRWAYS = 4,
+    OPTIMIZATION_GOAL_AVOID_TRAFFIC = 5,
+    OPTIMIZATION_GOAL_ARCHIPELAGO_CONSERVATIVE = 6,
+    UNRECOGNIZED = -1
+}
+export declare function optimizationGoalFromJSON(object: any): OptimizationGoal;
+export declare function optimizationGoalToJSON(object: OptimizationGoal): string;
+/**
+ * Inputs to a planning run.
+ *
+ * This replaces an earlier shape in which the request was a `keelson.Route`
+ * "template" — start/end/via smuggled in as waypoints, vessel limits in
+ * `info`, and the planner's own inputs as stringly-typed `constraint.*` keys
+ * inside an `Extensions` entry. A request is not a route: it has no id, no
+ * edition, no status, and nothing to sign. Typing it means a caller can see
+ * what a planner actually accepts.
+ */
+export interface PlanRouteRequest {
+    /**
+     * Ordered: first is the departure point, last is the destination, and any
+     * between them are via-points the route must pass through. At least two
+     * are required; a planner MUST reply `ErrorResponse(INVALID_ARGUMENT)`
+     * otherwise.
+     *
+     * `Coordinate`, not `Waypoint` — these are the positions the route must
+     * touch, not planned waypoints with turn radii and speeds. Those are the
+     * planner's output, not its input.
+     */
+    waypoints: Coordinate[];
+    /**
+     * Vessel dimensions, safety margins and limits the plan must respect —
+     * the same field set a produced `keelson.Route` carries, so a caller can
+     * round-trip the constraints of an existing route into a re-plan.
+     * `RouteInfo` carries no route identity (id, edition, status live on
+     * `Route`), which is exactly why it is the right request type: a request
+     * has nothing to identify.
+     */
+    constraints: RouteInfo | undefined;
+    goal: OptimizationGoal;
+    /**
+     * Upper bound on how many alternatives to reply with. 0 means the
+     * planner's own default. A planner MAY reply with fewer, and MUST NOT
+     * reply with more.
+     */
+    maxAlternatives: number;
+    /**
+     * Vendor-specific planning inputs — deployment tunings, experimental cost
+     * profiles. Anything that becomes generally useful should graduate to a
+     * typed field here rather than living in an `Any` forever.
+     */
+    extensions: Extensions | undefined;
+}
+export declare const PlanRouteRequest: MessageFns<PlanRouteRequest>;
+export type RoutePlannerDefinition = typeof RoutePlannerDefinition;
+export declare const RoutePlannerDefinition: {
+    readonly name: "RoutePlanner";
+    readonly fullName: "keelson.interfaces.route_planner.RoutePlanner";
+    readonly methods: {
+        /**
+         * Plan one or more routes between the requested points. Replies one
+         * `keelson.Route` per alternative — see note 1 in the file header about
+         * `consolidation=NONE`.
+         */
+        readonly plan_route: {
+            readonly name: "plan_route";
+            readonly requestType: MessageFns<PlanRouteRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./Route").MessageFns<Route>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * Re-run navigability and validation against a (possibly hand-edited)
+         * route, replying it annotated with `challenges`, `issues` and `status`.
+         * Takes a whole `keelson.Route` because that is genuinely the input.
+         */
+        readonly validate_route: {
+            readonly name: "validate_route";
+            readonly requestType: import("./Route").MessageFns<Route>;
+            readonly requestStream: false;
+            readonly responseType: import("./Route").MessageFns<Route>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * Fetch a stored route. `RouteRef` addresses a specific edition, so this
+         * resolves the same reference that appears inside other payloads — see
+         * §6.2. Replies `ErrorResponse(NOT_FOUND)` for an unknown id or a
+         * dangling edition.
+         */
+        readonly get_route: {
+            readonly name: "get_route";
+            readonly requestType: import("./Route").MessageFns<RouteRef>;
+            readonly requestStream: false;
+            readonly responseType: import("./Route").MessageFns<Route>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /**
+         * Select a route for execution: advances its status and bumps the edition.
+         * Mutating — see note 3 in the file header.
+         */
+        readonly select_route: {
+            readonly name: "select_route";
+            readonly requestType: import("./Route").MessageFns<RouteRef>;
+            readonly requestStream: false;
+            readonly responseType: import("./Route").MessageFns<Route>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

package/dist/interfaces/RoutePlanner.js

@@ -0,0 +1,268 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.6.1
+//   protoc               v6.30.2
+// source: RoutePlanner.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutePlannerDefinition = exports.PlanRouteRequest = exports.optimizationGoalToJSON = exports.optimizationGoalFromJSON = exports.OptimizationGoal = exports.protobufPackage = void 0;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+const Coordinate_1 = require("./Coordinate");
+const Route_1 = require("./Route");
+exports.protobufPackage = "keelson.interfaces.route_planner";
+/**
+ * What the planner should optimise for. A closed set, not the free-form
+ * string it replaced: a caller choosing a goal needs to know which goals
+ * exist, and an unrecognised label silently falling back to a default cost
+ * profile is the failure mode this prevents.
+ *
+ * Deployment-specific tunings (a particular trial's conservative profile, a
+ * pilot-matched profile) deliberately do NOT appear here — those are vendor
+ * configuration, and belong in `extensions` rather than in a vocabulary every
+ * consumer on the bus inherits.
+ */
+var OptimizationGoal;
+(function (OptimizationGoal) {
+    /** OPTIMIZATION_GOAL_UNSPECIFIED - planner picks its own default */
+    OptimizationGoal[OptimizationGoal["OPTIMIZATION_GOAL_UNSPECIFIED"] = 0] = "OPTIMIZATION_GOAL_UNSPECIFIED";
+    OptimizationGoal[OptimizationGoal["OPTIMIZATION_GOAL_SHORTEST"] = 1] = "OPTIMIZATION_GOAL_SHORTEST";
+    OptimizationGoal[OptimizationGoal["OPTIMIZATION_GOAL_FASTEST"] = 2] = "OPTIMIZATION_GOAL_FASTEST";
+    OptimizationGoal[OptimizationGoal["OPTIMIZATION_GOAL_SAFEST"] = 3] = "OPTIMIZATION_GOAL_SAFEST";
+    OptimizationGoal[OptimizationGoal["OPTIMIZATION_GOAL_PREFER_FAIRWAYS"] = 4] = "OPTIMIZATION_GOAL_PREFER_FAIRWAYS";
+    OptimizationGoal[OptimizationGoal["OPTIMIZATION_GOAL_AVOID_TRAFFIC"] = 5] = "OPTIMIZATION_GOAL_AVOID_TRAFFIC";
+    OptimizationGoal[OptimizationGoal["OPTIMIZATION_GOAL_ARCHIPELAGO_CONSERVATIVE"] = 6] = "OPTIMIZATION_GOAL_ARCHIPELAGO_CONSERVATIVE";
+    OptimizationGoal[OptimizationGoal["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(OptimizationGoal || (exports.OptimizationGoal = OptimizationGoal = {}));
+function optimizationGoalFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "OPTIMIZATION_GOAL_UNSPECIFIED":
+            return OptimizationGoal.OPTIMIZATION_GOAL_UNSPECIFIED;
+        case 1:
+        case "OPTIMIZATION_GOAL_SHORTEST":
+            return OptimizationGoal.OPTIMIZATION_GOAL_SHORTEST;
+        case 2:
+        case "OPTIMIZATION_GOAL_FASTEST":
+            return OptimizationGoal.OPTIMIZATION_GOAL_FASTEST;
+        case 3:
+        case "OPTIMIZATION_GOAL_SAFEST":
+            return OptimizationGoal.OPTIMIZATION_GOAL_SAFEST;
+        case 4:
+        case "OPTIMIZATION_GOAL_PREFER_FAIRWAYS":
+            return OptimizationGoal.OPTIMIZATION_GOAL_PREFER_FAIRWAYS;
+        case 5:
+        case "OPTIMIZATION_GOAL_AVOID_TRAFFIC":
+            return OptimizationGoal.OPTIMIZATION_GOAL_AVOID_TRAFFIC;
+        case 6:
+        case "OPTIMIZATION_GOAL_ARCHIPELAGO_CONSERVATIVE":
+            return OptimizationGoal.OPTIMIZATION_GOAL_ARCHIPELAGO_CONSERVATIVE;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return OptimizationGoal.UNRECOGNIZED;
+    }
+}
+exports.optimizationGoalFromJSON = optimizationGoalFromJSON;
+function optimizationGoalToJSON(object) {
+    switch (object) {
+        case OptimizationGoal.OPTIMIZATION_GOAL_UNSPECIFIED:
+            return "OPTIMIZATION_GOAL_UNSPECIFIED";
+        case OptimizationGoal.OPTIMIZATION_GOAL_SHORTEST:
+            return "OPTIMIZATION_GOAL_SHORTEST";
+        case OptimizationGoal.OPTIMIZATION_GOAL_FASTEST:
+            return "OPTIMIZATION_GOAL_FASTEST";
+        case OptimizationGoal.OPTIMIZATION_GOAL_SAFEST:
+            return "OPTIMIZATION_GOAL_SAFEST";
+        case OptimizationGoal.OPTIMIZATION_GOAL_PREFER_FAIRWAYS:
+            return "OPTIMIZATION_GOAL_PREFER_FAIRWAYS";
+        case OptimizationGoal.OPTIMIZATION_GOAL_AVOID_TRAFFIC:
+            return "OPTIMIZATION_GOAL_AVOID_TRAFFIC";
+        case OptimizationGoal.OPTIMIZATION_GOAL_ARCHIPELAGO_CONSERVATIVE:
+            return "OPTIMIZATION_GOAL_ARCHIPELAGO_CONSERVATIVE";
+        case OptimizationGoal.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.optimizationGoalToJSON = optimizationGoalToJSON;
+function createBasePlanRouteRequest() {
+    return { waypoints: [], constraints: undefined, goal: 0, maxAlternatives: 0, extensions: undefined };
+}
+exports.PlanRouteRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        for (const v of message.waypoints) {
+            Coordinate_1.Coordinate.encode(v, writer.uint32(10).fork()).join();
+        }
+        if (message.constraints !== undefined) {
+            Route_1.RouteInfo.encode(message.constraints, writer.uint32(18).fork()).join();
+        }
+        if (message.goal !== 0) {
+            writer.uint32(24).int32(message.goal);
+        }
+        if (message.maxAlternatives !== 0) {
+            writer.uint32(32).uint32(message.maxAlternatives);
+        }
+        if (message.extensions !== undefined) {
+            Route_1.Extensions.encode(message.extensions, writer.uint32(794).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePlanRouteRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.waypoints.push(Coordinate_1.Coordinate.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.constraints = Route_1.RouteInfo.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.goal = reader.int32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.maxAlternatives = reader.uint32();
+                    continue;
+                }
+                case 99: {
+                    if (tag !== 794) {
+                        break;
+                    }
+                    message.extensions = Route_1.Extensions.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            waypoints: globalThis.Array.isArray(object?.waypoints)
+                ? object.waypoints.map((e) => Coordinate_1.Coordinate.fromJSON(e))
+                : [],
+            constraints: isSet(object.constraints) ? Route_1.RouteInfo.fromJSON(object.constraints) : undefined,
+            goal: isSet(object.goal) ? optimizationGoalFromJSON(object.goal) : 0,
+            maxAlternatives: isSet(object.maxAlternatives) ? globalThis.Number(object.maxAlternatives) : 0,
+            extensions: isSet(object.extensions) ? Route_1.Extensions.fromJSON(object.extensions) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.waypoints?.length) {
+            obj.waypoints = message.waypoints.map((e) => Coordinate_1.Coordinate.toJSON(e));
+        }
+        if (message.constraints !== undefined) {
+            obj.constraints = Route_1.RouteInfo.toJSON(message.constraints);
+        }
+        if (message.goal !== 0) {
+            obj.goal = optimizationGoalToJSON(message.goal);
+        }
+        if (message.maxAlternatives !== 0) {
+            obj.maxAlternatives = Math.round(message.maxAlternatives);
+        }
+        if (message.extensions !== undefined) {
+            obj.extensions = Route_1.Extensions.toJSON(message.extensions);
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.PlanRouteRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBasePlanRouteRequest();
+        message.waypoints = object.waypoints?.map((e) => Coordinate_1.Coordinate.fromPartial(e)) || [];
+        message.constraints = (object.constraints !== undefined && object.constraints !== null)
+            ? Route_1.RouteInfo.fromPartial(object.constraints)
+            : undefined;
+        message.goal = object.goal ?? 0;
+        message.maxAlternatives = object.maxAlternatives ?? 0;
+        message.extensions = (object.extensions !== undefined && object.extensions !== null)
+            ? Route_1.Extensions.fromPartial(object.extensions)
+            : undefined;
+        return message;
+    },
+};
+exports.RoutePlannerDefinition = {
+    name: "RoutePlanner",
+    fullName: "keelson.interfaces.route_planner.RoutePlanner",
+    methods: {
+        /**
+         * Plan one or more routes between the requested points. Replies one
+         * `keelson.Route` per alternative — see note 1 in the file header about
+         * `consolidation=NONE`.
+         */
+        plan_route: {
+            name: "plan_route",
+            requestType: exports.PlanRouteRequest,
+            requestStream: false,
+            responseType: Route_1.Route,
+            responseStream: false,
+            options: {},
+        },
+        /**
+         * Re-run navigability and validation against a (possibly hand-edited)
+         * route, replying it annotated with `challenges`, `issues` and `status`.
+         * Takes a whole `keelson.Route` because that is genuinely the input.
+         */
+        validate_route: {
+            name: "validate_route",
+            requestType: Route_1.Route,
+            requestStream: false,
+            responseType: Route_1.Route,
+            responseStream: false,
+            options: {},
+        },
+        /**
+         * Fetch a stored route. `RouteRef` addresses a specific edition, so this
+         * resolves the same reference that appears inside other payloads — see
+         * §6.2. Replies `ErrorResponse(NOT_FOUND)` for an unknown id or a
+         * dangling edition.
+         */
+        get_route: {
+            name: "get_route",
+            requestType: Route_1.RouteRef,
+            requestStream: false,
+            responseType: Route_1.Route,
+            responseStream: false,
+            options: {},
+        },
+        /**
+         * Select a route for execution: advances its status and bumps the edition.
+         * Mutating — see note 3 in the file header.
+         */
+        select_route: {
+            name: "select_route",
+            requestType: Route_1.RouteRef,
+            requestStream: false,
+            responseType: Route_1.Route,
+            responseStream: false,
+            options: {},
+        },
+    },
+};
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

package/dist/interfaces/ScenarioCheckpoint.d.ts

@@ -0,0 +1,154 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare const protobufPackage = "keelson.interfaces.scenario_checkpoint";
+export interface SaveRequest {
+    /**
+     * Identifier for the checkpoint, as the responder understands it. An id
+     * within the responder's store, never a path: `save` writes to the
+     * responder's filesystem on behalf of anyone who can reach the bus, so an
+     * implementation is expected to validate this against an allowlist and
+     * refuse anything else with INVALID_ARGUMENT.
+     */
+    checkpointId: string;
+    /**
+     * Free text for whoever finds this checkpoint later: what it is a
+     * checkpoint OF. Carried back by list_checkpoints.
+     */
+    note: string;
+    /**
+     * Replace an existing checkpoint with this id. Without it, a taken id is
+     * refused — a checkpoint someone is relying on should not disappear
+     * because a second operator picked the same name.
+     */
+    overwrite: boolean;
+}
+export interface SaveResponse {
+    /**
+     * Echoed so a caller that let the responder normalise the id knows what to
+     * pass to restore.
+     */
+    checkpointId: string;
+    /**
+     * Where the clock was when the snapshot was taken. Returned rather than
+     * left to the status broadcast for the same reason StepResponse.tick is:
+     * the caller needs to know what it just captured without racing a 1 Hz
+     * status sample.
+     */
+    tick: number;
+    simulationTime: Date | undefined;
+}
+export interface RestoreRequest {
+    checkpointId: string;
+}
+export interface RestoreResponse {
+    /** Identity of the run that just began. New, never the saved one. */
+    runId: string;
+    /**
+     * What it branched from: the run the checkpoint was taken from, and the
+     * tick it was taken at. Also broadcast on keelson.ScenarioStatus, and
+     * returned here so a caller need not wait for the next status sample.
+     */
+    parentRunId: string;
+    parentTick: number;
+    simulationTime: Date | undefined;
+}
+export interface CheckpointInfo {
+    checkpointId: string;
+    /**
+     * Which scenario, and which exact content of it, this checkpoint belongs
+     * to. A checkpoint quoting a different scenario_hash than the loaded run
+     * is not restorable into it, however well the ids match.
+     */
+    scenarioId: string;
+    scenarioHash: string;
+    /** The run it was captured from, and where. */
+    runId: string;
+    tick: number;
+    /**
+     * Wall-clock time the checkpoint was written — when the operator took it,
+     * not a simulated time.
+     */
+    createdAt: Date | undefined;
+    note: string;
+    sizeBytes: number;
+}
+export interface ListCheckpointsRequest {
+    /**
+     * Optional; the responder decides what it means (an id prefix, a glob). No
+     * filter lists everything the responder is willing to list.
+     */
+    pattern: string;
+}
+export interface ListCheckpointsResponse {
+    /**
+     * Where the responder is listing from, for the same reason
+     * ListFilesResponse carries it: an operator choosing between two
+     * checkpoints called "before-crossing" needs to know they came from the
+     * same place.
+     */
+    baseDirectory: string;
+    /** Newest first. */
+    checkpoints: CheckpointInfo[];
+    /**
+     * True when the responder capped the listing. On the wire because a
+     * listing that quietly stopped short reads as "that is all of them", and
+     * an operator would go looking for a checkpoint that is in fact there.
+     */
+    truncated: boolean;
+}
+export declare const SaveRequest: MessageFns<SaveRequest>;
+export declare const SaveResponse: MessageFns<SaveResponse>;
+export declare const RestoreRequest: MessageFns<RestoreRequest>;
+export declare const RestoreResponse: MessageFns<RestoreResponse>;
+export declare const CheckpointInfo: MessageFns<CheckpointInfo>;
+export declare const ListCheckpointsRequest: MessageFns<ListCheckpointsRequest>;
+export declare const ListCheckpointsResponse: MessageFns<ListCheckpointsResponse>;
+export type ScenarioCheckpointDefinition = typeof ScenarioCheckpointDefinition;
+export declare const ScenarioCheckpointDefinition: {
+    readonly name: "ScenarioCheckpoint";
+    readonly fullName: "keelson.interfaces.scenario_checkpoint.ScenarioCheckpoint";
+    readonly methods: {
+        readonly save: {
+            readonly name: "save";
+            readonly requestType: MessageFns<SaveRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<SaveResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly restore: {
+            readonly name: "restore";
+            readonly requestType: MessageFns<RestoreRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<RestoreResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly list_checkpoints: {
+            readonly name: "list_checkpoints";
+            readonly requestType: MessageFns<ListCheckpointsRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<ListCheckpointsResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};