@rise-maritime/keelson-js 0.5.3 → 0.5.4-rc.1

package/dist/payloads/Route.d.ts

@@ -0,0 +1,541 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { SeverityLevel } from "./Severity";
+import { GeoJSON } from "./foxglove/GeoJSON";
+import { LocationFix } from "./foxglove/LocationFix";
+import { Any } from "./google/protobuf/any";
+import { Duration } from "./google/protobuf/duration";
+/** Autonomy level the route is authored for. */
+export declare enum AutonomyLevel {
+    AUTONOMY_LEVEL_UNSPECIFIED = 0,
+    MANUAL_ONLY = 1,
+    REMOTE_CONTROLLED = 2,
+    AUTONOMOUS_SUPERVISED = 3,
+    AUTONOMOUS_UNSUPERVISED = 4,
+    UNRECOGNIZED = -1
+}
+export declare function autonomyLevelFromJSON(object: any): AutonomyLevel;
+export declare function autonomyLevelToJSON(object: AutonomyLevel): string;
+/** Operational context for a leg or waypoint. */
+export declare enum OperationalContext {
+    OPERATIONAL_CONTEXT_UNSPECIFIED = 0,
+    OPERATIONAL_CONTEXT_OPEN_SEA = 1,
+    OPERATIONAL_CONTEXT_COASTAL = 2,
+    OPERATIONAL_CONTEXT_ARCHIPELAGO = 3,
+    OPERATIONAL_CONTEXT_PORT_APPROACH = 4,
+    OPERATIONAL_CONTEXT_PORT_AREA = 5,
+    OPERATIONAL_CONTEXT_RIVER_WATERS = 6,
+    OPERATIONAL_CONTEXT_LOCK = 7,
+    UNRECOGNIZED = -1
+}
+export declare function operationalContextFromJSON(object: any): OperationalContext;
+export declare function operationalContextToJSON(object: OperationalContext): string;
+/** Categorisation of route challenges (used in structured risk). */
+export declare enum RouteChallengeType {
+    ROUTE_CHALLENGE_TYPE_UNSPECIFIED = 0,
+    ROUTE_CHALLENGE_TYPE_SHALLOW_WATER = 1,
+    ROUTE_CHALLENGE_TYPE_TRAFFIC_DENSITY = 2,
+    ROUTE_CHALLENGE_TYPE_WEATHER_HAZARD = 3,
+    ROUTE_CHALLENGE_TYPE_PIRACY_SECURITY = 4,
+    ROUTE_CHALLENGE_TYPE_REGULATORY_LIMIT = 5,
+    ROUTE_CHALLENGE_TYPE_TECHNICAL_LIMIT = 6,
+    ROUTE_CHALLENGE_TYPE_OTHER = 7,
+    UNRECOGNIZED = -1
+}
+export declare function routeChallengeTypeFromJSON(object: any): RouteChallengeType;
+export declare function routeChallengeTypeToJSON(object: RouteChallengeType): string;
+/** Hazard zone classification. */
+export declare enum HazardZoneType {
+    HAZARD_ZONE_TYPE_UNSPECIFIED = 0,
+    HAZARD_ZONE_TYPE_STATIC_NOGO = 1,
+    HAZARD_ZONE_TYPE_DYNAMIC_NOGO = 2,
+    HAZARD_ZONE_TYPE_TRAFFIC = 3,
+    HAZARD_ZONE_TYPE_WEATHER = 4,
+    HAZARD_ZONE_TYPE_ENVIRONMENTAL = 5,
+    UNRECOGNIZED = -1
+}
+export declare function hazardZoneTypeFromJSON(object: any): HazardZoneType;
+export declare function hazardZoneTypeToJSON(object: HazardZoneType): string;
+/** COLREG encounter situation for an annotated leg. */
+export declare enum ColregSituation {
+    COLREG_SITUATION_UNSPECIFIED = 0,
+    COLREG_SITUATION_OVERTAKING = 1,
+    COLREG_SITUATION_CROSSING_STBD = 2,
+    COLREG_SITUATION_CROSSING_PORT = 3,
+    COLREG_SITUATION_HEAD_ON = 4,
+    UNRECOGNIZED = -1
+}
+export declare function colregSituationFromJSON(object: any): ColregSituation;
+export declare function colregSituationToJSON(object: ColregSituation): string;
+/** Annotated traffic intensity for a leg. */
+export declare enum ColregTrafficIntensity {
+    COLREG_TRAFFIC_INTENSITY_UNSPECIFIED = 0,
+    COLREG_TRAFFIC_INTENSITY_NONE = 1,
+    COLREG_TRAFFIC_INTENSITY_LIGHT = 2,
+    COLREG_TRAFFIC_INTENSITY_MODERATE = 3,
+    COLREG_TRAFFIC_INTENSITY_HEAVY = 4,
+    UNRECOGNIZED = -1
+}
+export declare function colregTrafficIntensityFromJSON(object: any): ColregTrafficIntensity;
+export declare function colregTrafficIntensityToJSON(object: ColregTrafficIntensity): string;
+/** Geometry type for a leg between waypoints. */
+export declare enum GeometryType {
+    GEOMETRY_TYPE_UNSPECIFIED = 0,
+    GEOMETRY_TYPE_LOXODROME = 1,
+    GEOMETRY_TYPE_ORTHODROME = 2,
+    UNRECOGNIZED = -1
+}
+export declare function geometryTypeFromJSON(object: any): GeometryType;
+export declare function geometryTypeToJSON(object: GeometryType): string;
+/**
+ * Lifecycle status for the route artifact (authoring + quality).
+ * Execution-side state (vessel sailing, paused, completed) lives on
+ * keelson.VoyageStatus and is intentionally NOT duplicated here.
+ */
+export declare enum RouteStatus {
+    ROUTE_STATUS_UNSPECIFIED = 0,
+    ROUTE_STATUS_INITIAL = 1,
+    ROUTE_STATUS_PLANNED = 2,
+    ROUTE_STATUS_RECOMMENDED = 3,
+    ROUTE_STATUS_ACKNOWLEDGED = 4,
+    /** ROUTE_STATUS_TERMINATED - Route artifact retired / superseded. */
+    ROUTE_STATUS_TERMINATED = 6,
+    ROUTE_STATUS_ERRORS = 7,
+    ROUTE_STATUS_INCOMPLETE = 8,
+    ROUTE_STATUS_ROUTE_ISSUES = 9,
+    UNRECOGNIZED = -1
+}
+export declare function routeStatusFromJSON(object: any): RouteStatus;
+export declare function routeStatusToJSON(object: RouteStatus): string;
+/** Required action for an ActionPoint. */
+export declare enum ActionPointRequiredAction {
+    ACTION_POINT_REQUIRED_ACTION_UNSPECIFIED = 0,
+    ACTION_POINT_REQUIRED_ACTION_USER_DEFINED = 1,
+    ACTION_POINT_REQUIRED_ACTION_REPORT = 2,
+    /** ACTION_POINT_REQUIRED_ACTION_UKCM - Under-keel clearance monitoring */
+    ACTION_POINT_REQUIRED_ACTION_UKCM = 3,
+    ACTION_POINT_REQUIRED_ACTION_NOTE = 4,
+    ACTION_POINT_REQUIRED_ACTION_PILOT_BOARDING = 5,
+    ACTION_POINT_REQUIRED_ACTION_FUEL_SWITCH = 6,
+    ACTION_POINT_REQUIRED_ACTION_MODE_SWITCH = 7,
+    ACTION_POINT_REQUIRED_ACTION_INCREASE_LOOKOUT = 8,
+    UNRECOGNIZED = -1
+}
+export declare function actionPointRequiredActionFromJSON(object: any): ActionPointRequiredAction;
+export declare function actionPointRequiredActionToJSON(object: ActionPointRequiredAction): string;
+/**
+ * Vendor- or model-specific data attached to any container. Each entry is
+ * scoped by manufacturer + name + version so multiple vendors can coexist on
+ * the same route without colliding.
+ *
+ * NOTE: the per-entry `payload` is a google.protobuf.Any — a deliberate,
+ * reviewed exception to the "no opaque escape hatch" guidance (#154). It is
+ * the vendor-extension mechanism for this RTZ 1.2 / S-421 standards-exchange
+ * format. Producers SHOULD prefer the typed `attributes` map for simple
+ * key/values and reserve Any for genuinely vendor-specific structured payloads.
+ */
+export interface Extensions {
+    $type: "keelson.Extensions";
+    entries: Extensions_Entry[];
+}
+export interface Extensions_Entry {
+    $type: "keelson.Extensions.Entry";
+    /** Reverse-DNS or short vendor identifier (e.g. "se.rise", "kongsberg"). */
+    manufacturer: string;
+    /** Vendor-scoped extension name. */
+    name: string;
+    /** Extension version (semver or vendor-defined). */
+    version: string;
+    /** Strongly-typed payload. */
+    payload: Any | undefined;
+    /** Lightweight key/value attributes that don't justify a typed payload. */
+    attributes: {
+        [key: string]: string;
+    };
+}
+export interface Extensions_Entry_AttributesEntry {
+    $type: "keelson.Extensions.Entry.AttributesEntry";
+    key: string;
+    value: string;
+}
+export interface Route {
+    $type: "keelson.Route";
+    /** Schema version this Route conforms to. */
+    version: string;
+    /** Globally unique route identifier (UUID recommended). */
+    routeId: string;
+    /** Monotonically increasing edition number; bumped on any edit. */
+    routeEditionNumber: number;
+    /**
+     * RTZ / S-421 format version this Route is compatible with
+     * (e.g. "RTZ-1.2", "S-421-FC1.0").
+     */
+    routeFormatVersion: string;
+    /** Lifecycle status. */
+    status: RouteStatus;
+    /** Time the route was created and last modified. */
+    createdAt: Date | undefined;
+    modifiedAt: Date | undefined;
+    info: RouteInfo | undefined;
+    waypoints: Waypoints | undefined;
+    schedules: Schedules | undefined;
+    actionPoints: ActionPoints | undefined;
+    /** Dynamic hazards / no-go areas valid for this route. */
+    hazardZones: HazardZone[];
+    /** Structured challenges / risks identified during planning. */
+    challenges: RouteChallenge[];
+    /** Free-form notes or issues against the route as a whole. */
+    issues: RouteIssue[];
+    /** Digital signatures attesting to the authenticity of this route edition. */
+    signatures: RouteSignature[];
+    extensions: Extensions | undefined;
+}
+/**
+ * Route artifact metadata. Vessel identity, port codes, planned dep/arr times,
+ * and voyage_id intentionally live on keelson.Voyage instead of here, so a
+ * Route can be authored once and executed by multiple voyages.
+ */
+export interface RouteInfo {
+    $type: "keelson.RouteInfo";
+    /** Human-readable route name. */
+    name: string;
+    /** Author of the route (planner / system name). */
+    author: string;
+    /** Organisation owning the route. */
+    authorOrganization: string;
+    /** Validity window for this route (e.g. tidal window, weather window). */
+    validFrom: Date | undefined;
+    validTo: Date | undefined;
+    /**
+     * -- Vessel-class plan constraints ------------------------------------------
+     * Dimensions the route was authored against. These are constraints, not
+     * identity — the vessel actually executing the voyage may differ within
+     * these bounds. Vessel identity lives on keelson.Voyage.
+     */
+    vesselLoaM: number;
+    /** Maximum beam */
+    vesselBeamM: number;
+    /** Maximum draft the route was planned for */
+    vesselDraftM: number;
+    /** Maximum height above waterline */
+    vesselAirDraftM: number;
+    /**
+     * -- Operational limits -----------------------------------------------------
+     * Limits the route is valid under. Use `optional` so a zero value means
+     * "no limit applies" only when the field is set; an unset field means the
+     * limit is unknown / not specified.
+     */
+    maxRollDeg?: number | undefined;
+    maxWaveHeightM?: number | undefined;
+    maxWindSpeedMps?: number | undefined;
+    minSpeedKnots?: number | undefined;
+    maxSpeedKnots?: number | undefined;
+    /**
+     * -- Optimization & autonomy ------------------------------------------------
+     * Free-form optimization method label (e.g. "fuel-min", "eta-min", "weather-routed").
+     */
+    optimizationMethod: string;
+    /** Target autonomy level this route is authored for. */
+    autonomyLevel: AutonomyLevel;
+    changeHistory: RouteInfo_Change[];
+    extensions: Extensions | undefined;
+}
+/** -- Change history --------------------------------------------------------- */
+export interface RouteInfo_Change {
+    $type: "keelson.RouteInfo.Change";
+    at: Date | undefined;
+    author: string;
+    description: string;
+    editionNumber: number;
+}
+export interface Waypoints {
+    $type: "keelson.Waypoints";
+    /** Default values applied to any waypoint or leg that doesn't override them. */
+    defaults: DefaultWaypoint | undefined;
+    /** Ordered list of waypoints, in route order. */
+    waypoint: Waypoint[];
+    extensions: Extensions | undefined;
+}
+/** Default values for waypoint/leg fields. RTZ-aligned. */
+export interface DefaultWaypoint {
+    $type: "keelson.DefaultWaypoint";
+    leg: Leg | undefined;
+    radiusM: number;
+    plannedSogKnots: number;
+}
+export interface Waypoint {
+    $type: "keelson.Waypoint";
+    /** Stable waypoint identifier. */
+    id: number;
+    /** Revision counter for this specific waypoint. */
+    revision: number;
+    /** Human-readable name (e.g. "WP-007 East of Hanö"). */
+    name: string;
+    /** WGS-84 position. */
+    position: LocationFix | undefined;
+    /** Planned speed over ground when leaving this waypoint. */
+    plannedSogKnots: number;
+    /** Turn radius for fly-by, in metres. */
+    radiusM: number;
+    /** Maximum rate of turn during the turn, degrees per second. */
+    rateOfTurnDegps: number;
+    /** Distance before the turn at which wheel-over should be ordered, metres. */
+    wheelOverDistanceM: number;
+    /**
+     * If true, the waypoint is locked and may not be edited by autonomous
+     * re-routing.
+     */
+    lock: boolean;
+    /** Operational context for this waypoint (open sea, port approach, lock, ...). */
+    operationalContext: OperationalContext;
+    /** Outgoing leg from this waypoint to the next. The last waypoint has none. */
+    leg: Leg | undefined;
+    /** Free-form notes attached to this waypoint. */
+    note: string;
+    extensions: Extensions | undefined;
+}
+export interface Leg {
+    $type: "keelson.Leg";
+    /**
+     * Cross-track distance (XTD) limits and monitoring thresholds, in metres.
+     * `optional` so producers can distinguish "no XTD limit" (unset) from
+     * "zero XTD limit" (set to 0).
+     */
+    xtdPortM?: number | undefined;
+    xtdStarboardM?: number | undefined;
+    xtdMonitoringPortM?: number | undefined;
+    xtdMonitoringStarboardM?: number | undefined;
+    /**
+     * Safety contour (depth in metres below chart datum) below which the route
+     * is considered unsafe.
+     */
+    safetyContourM?: number | undefined;
+    /** Minimum allowed depth on this leg, in metres. */
+    safetyDepthM?: number | undefined;
+    /** Static under-keel clearance, in metres. */
+    ukcStaticM?: number | undefined;
+    /** Dynamic under-keel clearance margin, in metres. */
+    ukcDynamicM?: number | undefined;
+    /** Planned draughts for this leg. */
+    draughtBowM: number;
+    draughtSternM: number;
+    draughtMeanM: number;
+    /** Geometry type along this leg. */
+    geometryType: GeometryType;
+    /** Speed envelope — Speed Over Ground (knots). */
+    sogMinKnots: number;
+    sogMaxKnots: number;
+    /** Speed envelope — Speed Through Water (knots). */
+    stwMinKnots: number;
+    stwMaxKnots: number;
+    /**
+     * Dimensional limits for the leg (e.g. bridge clearances, lock dimensions).
+     * `optional` so unset means "no limit specified".
+     */
+    draughtMaxM?: number | undefined;
+    airDraftMaxM?: number | undefined;
+    beamMaxM?: number | undefined;
+    lengthMaxM?: number | undefined;
+    /** Free-text reporting / handover text for this leg. */
+    report: string;
+    /** Free-form notes. */
+    note: string;
+    /** COLREG annotations. */
+    colregSituation: ColregSituation;
+    colregTrafficIntensity: ColregTrafficIntensity;
+    extensions: Extensions | undefined;
+}
+export interface Schedules {
+    $type: "keelson.Schedules";
+    /** Multiple schedules can coexist (e.g. "manual", "weather-optimized"). */
+    schedule: Schedule[];
+    extensions: Extensions | undefined;
+}
+export interface Schedule {
+    $type: "keelson.Schedule";
+    /** Schedule identifier (unique within the route). */
+    id: string;
+    /** Free-text name. */
+    name: string;
+    origin: Schedule_Origin;
+    /** Ordered list of schedule entries, one per waypoint. */
+    element: ScheduleElement[];
+    extensions: Extensions | undefined;
+}
+/** Whether this schedule was authored manually or computed. */
+export declare enum Schedule_Origin {
+    ORIGIN_UNSPECIFIED = 0,
+    MANUAL = 1,
+    CALCULATED = 2,
+    UNRECOGNIZED = -1
+}
+export declare function schedule_OriginFromJSON(object: any): Schedule_Origin;
+export declare function schedule_OriginToJSON(object: Schedule_Origin): string;
+export interface ScheduleElement {
+    $type: "keelson.ScheduleElement";
+    /** ID of the waypoint this entry refers to. */
+    waypointId: number;
+    /** Estimated time of arrival / departure with allowed windows. */
+    eta: Date | undefined;
+    etaWindowStart: Date | undefined;
+    etaWindowEnd: Date | undefined;
+    etd: Date | undefined;
+    etdWindowStart: Date | undefined;
+    etdWindowEnd: Date | undefined;
+    /** Planned duration of stay at this waypoint (port, anchorage, ...). */
+    stay: Duration | undefined;
+    /** -- Environmental forecast for this leg ------------------------------------ */
+    windSpeedMps: number;
+    windDirectionDeg: number;
+    currentSpeedMps: number;
+    currentDirectionDeg: number;
+    waveHeightM: number;
+    wavePeriodS: number;
+    waveDirectionDeg: number;
+    /** -- Energy / propulsion plan ---------------------------------------------- */
+    plannedRpm: number;
+    plannedPropellerPitchPct: number;
+    plannedFuelKg: number;
+    /** Fuel savings versus a reference plan, in kilograms (negative = increase). */
+    fuelSavingVsReferenceKg: number;
+    extensions: Extensions | undefined;
+}
+export interface ActionPoints {
+    $type: "keelson.ActionPoints";
+    actionPoint: ActionPoint[];
+    extensions: Extensions | undefined;
+}
+export interface ActionPoint {
+    $type: "keelson.ActionPoint";
+    /** Stable action-point identifier. */
+    id: string;
+    /** Human-readable name. */
+    name: string;
+    /**
+     * -- Geometry ---------------------------------------------------------------
+     * Either a point + radius (preferred for simple action points) or an area
+     * expressed as GeoJSON.
+     */
+    position: LocationFix | undefined;
+    radiusM: number;
+    area: GeoJSON | undefined;
+    /**
+     * Lead time before crossing the geometry at which the action should be
+     * triggered (e.g. 5 minutes before pilot boarding ground).
+     */
+    timeToAct: Duration | undefined;
+    /** Required action. */
+    requiredAction: ActionPointRequiredAction;
+    /**
+     * Free-form action description (always required when required_action is
+     * USER_DEFINED; otherwise supplements the enum).
+     */
+    description: string;
+    extensions: Extensions | undefined;
+}
+export interface HazardZone {
+    $type: "keelson.HazardZone";
+    /** Stable hazard identifier. */
+    id: string;
+    type: HazardZoneType;
+    /** Hazard severity. */
+    severity: SeverityLevel;
+    /** Free-text description. */
+    description: string;
+    /** Either a centre + radius or a polygon expressed as GeoJSON. */
+    centre: LocationFix | undefined;
+    radiusM: number;
+    polygon: GeoJSON | undefined;
+    /** Validity window for the hazard. */
+    validFrom: Date | undefined;
+    validTo: Date | undefined;
+    extensions: Extensions | undefined;
+}
+export interface RouteChallenge {
+    $type: "keelson.RouteChallenge";
+    id: string;
+    type: RouteChallengeType;
+    severity: SeverityLevel;
+    description: string;
+    /** Waypoint IDs the challenge applies to (empty = whole route). */
+    waypointIds: number[];
+    extensions: Extensions | undefined;
+}
+export interface RouteIssue {
+    $type: "keelson.RouteIssue";
+    id: string;
+    severity: SeverityLevel;
+    description: string;
+    raisedAt: Date | undefined;
+    raisedBy: string;
+    extensions: Extensions | undefined;
+}
+export interface RouteSignature {
+    $type: "keelson.RouteSignature";
+    /** Free-form signer identifier (e.g. user id, system id). */
+    signerId: string;
+    /** Signer role (e.g. "master", "planner", "shore-control"). */
+    signerRole: string;
+    /** Signing algorithm (e.g. "ed25519", "ecdsa-p256-sha256"). */
+    algorithm: string;
+    /** Raw signature bytes. */
+    signature: Uint8Array;
+    /** Time of signing. */
+    signedAt: Date | undefined;
+    /** Reference to the public key used to verify (key id, URL, fingerprint). */
+    keyReference: string;
+    extensions: Extensions | undefined;
+}
+/**
+ * Standalone, structured payload for the `route_status` subject. Replaces the
+ * previous TimestampedString mapping so subscribers can act on the standard
+ * RouteStatus enum without parsing free-form text.
+ */
+export interface RouteStatusUpdate {
+    $type: "keelson.RouteStatusUpdate";
+    timestamp: Date | undefined;
+    routeId: string;
+    routeEditionNumber: number;
+    status: RouteStatus;
+    changedBy: string;
+    note: string;
+}
+export declare const Extensions: MessageFns<Extensions, "keelson.Extensions">;
+export declare const Extensions_Entry: MessageFns<Extensions_Entry, "keelson.Extensions.Entry">;
+export declare const Extensions_Entry_AttributesEntry: MessageFns<Extensions_Entry_AttributesEntry, "keelson.Extensions.Entry.AttributesEntry">;
+export declare const Route: MessageFns<Route, "keelson.Route">;
+export declare const RouteInfo: MessageFns<RouteInfo, "keelson.RouteInfo">;
+export declare const RouteInfo_Change: MessageFns<RouteInfo_Change, "keelson.RouteInfo.Change">;
+export declare const Waypoints: MessageFns<Waypoints, "keelson.Waypoints">;
+export declare const DefaultWaypoint: MessageFns<DefaultWaypoint, "keelson.DefaultWaypoint">;
+export declare const Waypoint: MessageFns<Waypoint, "keelson.Waypoint">;
+export declare const Leg: MessageFns<Leg, "keelson.Leg">;
+export declare const Schedules: MessageFns<Schedules, "keelson.Schedules">;
+export declare const Schedule: MessageFns<Schedule, "keelson.Schedule">;
+export declare const ScheduleElement: MessageFns<ScheduleElement, "keelson.ScheduleElement">;
+export declare const ActionPoints: MessageFns<ActionPoints, "keelson.ActionPoints">;
+export declare const ActionPoint: MessageFns<ActionPoint, "keelson.ActionPoint">;
+export declare const HazardZone: MessageFns<HazardZone, "keelson.HazardZone">;
+export declare const RouteChallenge: MessageFns<RouteChallenge, "keelson.RouteChallenge">;
+export declare const RouteIssue: MessageFns<RouteIssue, "keelson.RouteIssue">;
+export declare const RouteSignature: MessageFns<RouteSignature, "keelson.RouteSignature">;
+export declare const RouteStatusUpdate: MessageFns<RouteStatusUpdate, "keelson.RouteStatusUpdate">;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+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 Exclude<keyof T, "$type">]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+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> | "$type">]: never;
+};
+interface MessageFns<T, V extends string> {
+    readonly $type: V;
+    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 {};