@sparkdreamnft/sparkdreamjs 0.0.7 → 0.0.8

package/sparkdream/season/v1/season_transition_state.d.ts

@@ -0,0 +1,93 @@
+import { TransitionPhase } from "./enums";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * SeasonTransitionState tracks the progress of a season transition.
+ * @name SeasonTransitionState
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.SeasonTransitionState
+ */
+export interface SeasonTransitionState {
+    /**
+     * Current transition phase
+     */
+    phase: TransitionPhase;
+    /**
+     * Number of items processed in current phase
+     */
+    processedCount: bigint;
+    /**
+     * Total items to process in current phase
+     */
+    totalCount: bigint;
+    /**
+     * Last processed item identifier
+     */
+    lastProcessed: string;
+    /**
+     * Block when transition started
+     */
+    transitionStart: bigint;
+    /**
+     * Whether the chain is in maintenance mode
+     */
+    maintenanceMode: boolean;
+}
+export interface SeasonTransitionStateProtoMsg {
+    typeUrl: "/sparkdream.season.v1.SeasonTransitionState";
+    value: Uint8Array;
+}
+/**
+ * SeasonTransitionState tracks the progress of a season transition.
+ * @name SeasonTransitionStateAmino
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.SeasonTransitionState
+ */
+export interface SeasonTransitionStateAmino {
+    /**
+     * Current transition phase
+     */
+    phase?: TransitionPhase;
+    /**
+     * Number of items processed in current phase
+     */
+    processed_count?: string;
+    /**
+     * Total items to process in current phase
+     */
+    total_count?: string;
+    /**
+     * Last processed item identifier
+     */
+    last_processed?: string;
+    /**
+     * Block when transition started
+     */
+    transition_start?: string;
+    /**
+     * Whether the chain is in maintenance mode
+     */
+    maintenance_mode?: boolean;
+}
+export interface SeasonTransitionStateAminoMsg {
+    type: "/sparkdream.season.v1.SeasonTransitionState";
+    value: SeasonTransitionStateAmino;
+}
+/**
+ * SeasonTransitionState tracks the progress of a season transition.
+ * @name SeasonTransitionState
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.SeasonTransitionState
+ */
+export declare const SeasonTransitionState: {
+    typeUrl: string;
+    encode(message: SeasonTransitionState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): SeasonTransitionState;
+    fromPartial(object: DeepPartial<SeasonTransitionState>): SeasonTransitionState;
+    fromAmino(object: SeasonTransitionStateAmino): SeasonTransitionState;
+    toAmino(message: SeasonTransitionState): SeasonTransitionStateAmino;
+    fromAminoMsg(object: SeasonTransitionStateAminoMsg): SeasonTransitionState;
+    fromProtoMsg(message: SeasonTransitionStateProtoMsg): SeasonTransitionState;
+    toProto(message: SeasonTransitionState): Uint8Array;
+    toProtoMsg(message: SeasonTransitionState): SeasonTransitionStateProtoMsg;
+};

package/sparkdream/season/v1/season_transition_state.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeasonTransitionState = void 0;
+const binary_1 = require("../../../binary");
+function createBaseSeasonTransitionState() {
+    return {
+        phase: 0,
+        processedCount: BigInt(0),
+        totalCount: BigInt(0),
+        lastProcessed: "",
+        transitionStart: BigInt(0),
+        maintenanceMode: false
+    };
+}
+/**
+ * SeasonTransitionState tracks the progress of a season transition.
+ * @name SeasonTransitionState
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.SeasonTransitionState
+ */
+exports.SeasonTransitionState = {
+    typeUrl: "/sparkdream.season.v1.SeasonTransitionState",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.phase !== 0) {
+            writer.uint32(8).int32(message.phase);
+        }
+        if (message.processedCount !== BigInt(0)) {
+            writer.uint32(16).uint64(message.processedCount);
+        }
+        if (message.totalCount !== BigInt(0)) {
+            writer.uint32(24).uint64(message.totalCount);
+        }
+        if (message.lastProcessed !== "") {
+            writer.uint32(34).string(message.lastProcessed);
+        }
+        if (message.transitionStart !== BigInt(0)) {
+            writer.uint32(40).int64(message.transitionStart);
+        }
+        if (message.maintenanceMode === true) {
+            writer.uint32(48).bool(message.maintenanceMode);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSeasonTransitionState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.phase = reader.int32();
+                    break;
+                case 2:
+                    message.processedCount = reader.uint64();
+                    break;
+                case 3:
+                    message.totalCount = reader.uint64();
+                    break;
+                case 4:
+                    message.lastProcessed = reader.string();
+                    break;
+                case 5:
+                    message.transitionStart = reader.int64();
+                    break;
+                case 6:
+                    message.maintenanceMode = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseSeasonTransitionState();
+        message.phase = object.phase ?? 0;
+        message.processedCount = object.processedCount !== undefined && object.processedCount !== null ? BigInt(object.processedCount.toString()) : BigInt(0);
+        message.totalCount = object.totalCount !== undefined && object.totalCount !== null ? BigInt(object.totalCount.toString()) : BigInt(0);
+        message.lastProcessed = object.lastProcessed ?? "";
+        message.transitionStart = object.transitionStart !== undefined && object.transitionStart !== null ? BigInt(object.transitionStart.toString()) : BigInt(0);
+        message.maintenanceMode = object.maintenanceMode ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseSeasonTransitionState();
+        if (object.phase !== undefined && object.phase !== null) {
+            message.phase = object.phase;
+        }
+        if (object.processed_count !== undefined && object.processed_count !== null) {
+            message.processedCount = BigInt(object.processed_count);
+        }
+        if (object.total_count !== undefined && object.total_count !== null) {
+            message.totalCount = BigInt(object.total_count);
+        }
+        if (object.last_processed !== undefined && object.last_processed !== null) {
+            message.lastProcessed = object.last_processed;
+        }
+        if (object.transition_start !== undefined && object.transition_start !== null) {
+            message.transitionStart = BigInt(object.transition_start);
+        }
+        if (object.maintenance_mode !== undefined && object.maintenance_mode !== null) {
+            message.maintenanceMode = object.maintenance_mode;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.phase = message.phase === 0 ? undefined : message.phase;
+        obj.processed_count = message.processedCount !== BigInt(0) ? message.processedCount?.toString() : undefined;
+        obj.total_count = message.totalCount !== BigInt(0) ? message.totalCount?.toString() : undefined;
+        obj.last_processed = message.lastProcessed === "" ? undefined : message.lastProcessed;
+        obj.transition_start = message.transitionStart !== BigInt(0) ? message.transitionStart?.toString() : undefined;
+        obj.maintenance_mode = message.maintenanceMode === false ? undefined : message.maintenanceMode;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.SeasonTransitionState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.SeasonTransitionState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.SeasonTransitionState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.season.v1.SeasonTransitionState",
+            value: exports.SeasonTransitionState.encode(message).finish()
+        };
+    }
+};

package/sparkdream/season/v1/title.d.ts

@@ -0,0 +1,109 @@
+import { Rarity, RequirementType } from "./enums";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * Title defines a title that can be displayed by members.
+ * @name Title
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.Title
+ */
+export interface Title {
+    /**
+     * Unique title ID
+     */
+    titleId: string;
+    /**
+     * Title name (displayed to users)
+     */
+    name: string;
+    /**
+     * Title description
+     */
+    description: string;
+    /**
+     * Rarity level
+     */
+    rarity: Rarity;
+    /**
+     * Type of requirement to unlock this title
+     */
+    requirementType: RequirementType;
+    /**
+     * Threshold value for the requirement
+     */
+    requirementThreshold: bigint;
+    /**
+     * Season requirement (0 = any season)
+     */
+    requirementSeason: bigint;
+    /**
+     * Whether this is a seasonal title that expires
+     */
+    seasonal: boolean;
+}
+export interface TitleProtoMsg {
+    typeUrl: "/sparkdream.season.v1.Title";
+    value: Uint8Array;
+}
+/**
+ * Title defines a title that can be displayed by members.
+ * @name TitleAmino
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.Title
+ */
+export interface TitleAmino {
+    /**
+     * Unique title ID
+     */
+    title_id?: string;
+    /**
+     * Title name (displayed to users)
+     */
+    name?: string;
+    /**
+     * Title description
+     */
+    description?: string;
+    /**
+     * Rarity level
+     */
+    rarity?: Rarity;
+    /**
+     * Type of requirement to unlock this title
+     */
+    requirement_type?: RequirementType;
+    /**
+     * Threshold value for the requirement
+     */
+    requirement_threshold?: string;
+    /**
+     * Season requirement (0 = any season)
+     */
+    requirement_season?: string;
+    /**
+     * Whether this is a seasonal title that expires
+     */
+    seasonal?: boolean;
+}
+export interface TitleAminoMsg {
+    type: "/sparkdream.season.v1.Title";
+    value: TitleAmino;
+}
+/**
+ * Title defines a title that can be displayed by members.
+ * @name Title
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.Title
+ */
+export declare const Title: {
+    typeUrl: string;
+    encode(message: Title, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): Title;
+    fromPartial(object: DeepPartial<Title>): Title;
+    fromAmino(object: TitleAmino): Title;
+    toAmino(message: Title): TitleAmino;
+    fromAminoMsg(object: TitleAminoMsg): Title;
+    fromProtoMsg(message: TitleProtoMsg): Title;
+    toProto(message: Title): Uint8Array;
+    toProtoMsg(message: Title): TitleProtoMsg;
+};

package/sparkdream/season/v1/title.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Title = void 0;
+const binary_1 = require("../../../binary");
+function createBaseTitle() {
+    return {
+        titleId: "",
+        name: "",
+        description: "",
+        rarity: 0,
+        requirementType: 0,
+        requirementThreshold: BigInt(0),
+        requirementSeason: BigInt(0),
+        seasonal: false
+    };
+}
+/**
+ * Title defines a title that can be displayed by members.
+ * @name Title
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.Title
+ */
+exports.Title = {
+    typeUrl: "/sparkdream.season.v1.Title",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.titleId !== "") {
+            writer.uint32(10).string(message.titleId);
+        }
+        if (message.name !== "") {
+            writer.uint32(18).string(message.name);
+        }
+        if (message.description !== "") {
+            writer.uint32(26).string(message.description);
+        }
+        if (message.rarity !== 0) {
+            writer.uint32(32).int32(message.rarity);
+        }
+        if (message.requirementType !== 0) {
+            writer.uint32(40).int32(message.requirementType);
+        }
+        if (message.requirementThreshold !== BigInt(0)) {
+            writer.uint32(48).uint64(message.requirementThreshold);
+        }
+        if (message.requirementSeason !== BigInt(0)) {
+            writer.uint32(56).uint64(message.requirementSeason);
+        }
+        if (message.seasonal === true) {
+            writer.uint32(64).bool(message.seasonal);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTitle();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.titleId = reader.string();
+                    break;
+                case 2:
+                    message.name = reader.string();
+                    break;
+                case 3:
+                    message.description = reader.string();
+                    break;
+                case 4:
+                    message.rarity = reader.int32();
+                    break;
+                case 5:
+                    message.requirementType = reader.int32();
+                    break;
+                case 6:
+                    message.requirementThreshold = reader.uint64();
+                    break;
+                case 7:
+                    message.requirementSeason = reader.uint64();
+                    break;
+                case 8:
+                    message.seasonal = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseTitle();
+        message.titleId = object.titleId ?? "";
+        message.name = object.name ?? "";
+        message.description = object.description ?? "";
+        message.rarity = object.rarity ?? 0;
+        message.requirementType = object.requirementType ?? 0;
+        message.requirementThreshold = object.requirementThreshold !== undefined && object.requirementThreshold !== null ? BigInt(object.requirementThreshold.toString()) : BigInt(0);
+        message.requirementSeason = object.requirementSeason !== undefined && object.requirementSeason !== null ? BigInt(object.requirementSeason.toString()) : BigInt(0);
+        message.seasonal = object.seasonal ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseTitle();
+        if (object.title_id !== undefined && object.title_id !== null) {
+            message.titleId = object.title_id;
+        }
+        if (object.name !== undefined && object.name !== null) {
+            message.name = object.name;
+        }
+        if (object.description !== undefined && object.description !== null) {
+            message.description = object.description;
+        }
+        if (object.rarity !== undefined && object.rarity !== null) {
+            message.rarity = object.rarity;
+        }
+        if (object.requirement_type !== undefined && object.requirement_type !== null) {
+            message.requirementType = object.requirement_type;
+        }
+        if (object.requirement_threshold !== undefined && object.requirement_threshold !== null) {
+            message.requirementThreshold = BigInt(object.requirement_threshold);
+        }
+        if (object.requirement_season !== undefined && object.requirement_season !== null) {
+            message.requirementSeason = BigInt(object.requirement_season);
+        }
+        if (object.seasonal !== undefined && object.seasonal !== null) {
+            message.seasonal = object.seasonal;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.title_id = message.titleId === "" ? undefined : message.titleId;
+        obj.name = message.name === "" ? undefined : message.name;
+        obj.description = message.description === "" ? undefined : message.description;
+        obj.rarity = message.rarity === 0 ? undefined : message.rarity;
+        obj.requirement_type = message.requirementType === 0 ? undefined : message.requirementType;
+        obj.requirement_threshold = message.requirementThreshold !== BigInt(0) ? message.requirementThreshold?.toString() : undefined;
+        obj.requirement_season = message.requirementSeason !== BigInt(0) ? message.requirementSeason?.toString() : undefined;
+        obj.seasonal = message.seasonal === false ? undefined : message.seasonal;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.Title.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.Title.decode(message.value);
+    },
+    toProto(message) {
+        return exports.Title.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.season.v1.Title",
+            value: exports.Title.encode(message).finish()
+        };
+    }
+};

package/sparkdream/season/v1/transition_recovery_state.d.ts

@@ -0,0 +1,85 @@
+import { TransitionPhase } from "./enums";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { DeepPartial } from "../../../helpers";
+/**
+ * TransitionRecoveryState tracks recovery from failed season transitions.
+ * @name TransitionRecoveryState
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.TransitionRecoveryState
+ */
+export interface TransitionRecoveryState {
+    /**
+     * Block of the last recovery attempt
+     */
+    lastAttemptBlock: bigint;
+    /**
+     * Phase where the transition failed
+     */
+    failedPhase: TransitionPhase;
+    /**
+     * Number of consecutive failures
+     */
+    failureCount: bigint;
+    /**
+     * Error message from last failure
+     */
+    lastError: string;
+    /**
+     * Whether recovery mode is active
+     */
+    recoveryMode: boolean;
+}
+export interface TransitionRecoveryStateProtoMsg {
+    typeUrl: "/sparkdream.season.v1.TransitionRecoveryState";
+    value: Uint8Array;
+}
+/**
+ * TransitionRecoveryState tracks recovery from failed season transitions.
+ * @name TransitionRecoveryStateAmino
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.TransitionRecoveryState
+ */
+export interface TransitionRecoveryStateAmino {
+    /**
+     * Block of the last recovery attempt
+     */
+    last_attempt_block?: string;
+    /**
+     * Phase where the transition failed
+     */
+    failed_phase?: TransitionPhase;
+    /**
+     * Number of consecutive failures
+     */
+    failure_count?: string;
+    /**
+     * Error message from last failure
+     */
+    last_error?: string;
+    /**
+     * Whether recovery mode is active
+     */
+    recovery_mode?: boolean;
+}
+export interface TransitionRecoveryStateAminoMsg {
+    type: "/sparkdream.season.v1.TransitionRecoveryState";
+    value: TransitionRecoveryStateAmino;
+}
+/**
+ * TransitionRecoveryState tracks recovery from failed season transitions.
+ * @name TransitionRecoveryState
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.TransitionRecoveryState
+ */
+export declare const TransitionRecoveryState: {
+    typeUrl: string;
+    encode(message: TransitionRecoveryState, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): TransitionRecoveryState;
+    fromPartial(object: DeepPartial<TransitionRecoveryState>): TransitionRecoveryState;
+    fromAmino(object: TransitionRecoveryStateAmino): TransitionRecoveryState;
+    toAmino(message: TransitionRecoveryState): TransitionRecoveryStateAmino;
+    fromAminoMsg(object: TransitionRecoveryStateAminoMsg): TransitionRecoveryState;
+    fromProtoMsg(message: TransitionRecoveryStateProtoMsg): TransitionRecoveryState;
+    toProto(message: TransitionRecoveryState): Uint8Array;
+    toProtoMsg(message: TransitionRecoveryState): TransitionRecoveryStateProtoMsg;
+};

package/sparkdream/season/v1/transition_recovery_state.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransitionRecoveryState = void 0;
+const binary_1 = require("../../../binary");
+function createBaseTransitionRecoveryState() {
+    return {
+        lastAttemptBlock: BigInt(0),
+        failedPhase: 0,
+        failureCount: BigInt(0),
+        lastError: "",
+        recoveryMode: false
+    };
+}
+/**
+ * TransitionRecoveryState tracks recovery from failed season transitions.
+ * @name TransitionRecoveryState
+ * @package sparkdream.season.v1
+ * @see proto type: sparkdream.season.v1.TransitionRecoveryState
+ */
+exports.TransitionRecoveryState = {
+    typeUrl: "/sparkdream.season.v1.TransitionRecoveryState",
+    encode(message, writer = binary_1.BinaryWriter.create()) {
+        if (message.lastAttemptBlock !== BigInt(0)) {
+            writer.uint32(8).int64(message.lastAttemptBlock);
+        }
+        if (message.failedPhase !== 0) {
+            writer.uint32(16).int32(message.failedPhase);
+        }
+        if (message.failureCount !== BigInt(0)) {
+            writer.uint32(24).uint64(message.failureCount);
+        }
+        if (message.lastError !== "") {
+            writer.uint32(34).string(message.lastError);
+        }
+        if (message.recoveryMode === true) {
+            writer.uint32(40).bool(message.recoveryMode);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof binary_1.BinaryReader ? input : new binary_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTransitionRecoveryState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.lastAttemptBlock = reader.int64();
+                    break;
+                case 2:
+                    message.failedPhase = reader.int32();
+                    break;
+                case 3:
+                    message.failureCount = reader.uint64();
+                    break;
+                case 4:
+                    message.lastError = reader.string();
+                    break;
+                case 5:
+                    message.recoveryMode = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseTransitionRecoveryState();
+        message.lastAttemptBlock = object.lastAttemptBlock !== undefined && object.lastAttemptBlock !== null ? BigInt(object.lastAttemptBlock.toString()) : BigInt(0);
+        message.failedPhase = object.failedPhase ?? 0;
+        message.failureCount = object.failureCount !== undefined && object.failureCount !== null ? BigInt(object.failureCount.toString()) : BigInt(0);
+        message.lastError = object.lastError ?? "";
+        message.recoveryMode = object.recoveryMode ?? false;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseTransitionRecoveryState();
+        if (object.last_attempt_block !== undefined && object.last_attempt_block !== null) {
+            message.lastAttemptBlock = BigInt(object.last_attempt_block);
+        }
+        if (object.failed_phase !== undefined && object.failed_phase !== null) {
+            message.failedPhase = object.failed_phase;
+        }
+        if (object.failure_count !== undefined && object.failure_count !== null) {
+            message.failureCount = BigInt(object.failure_count);
+        }
+        if (object.last_error !== undefined && object.last_error !== null) {
+            message.lastError = object.last_error;
+        }
+        if (object.recovery_mode !== undefined && object.recovery_mode !== null) {
+            message.recoveryMode = object.recovery_mode;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.last_attempt_block = message.lastAttemptBlock !== BigInt(0) ? message.lastAttemptBlock?.toString() : undefined;
+        obj.failed_phase = message.failedPhase === 0 ? undefined : message.failedPhase;
+        obj.failure_count = message.failureCount !== BigInt(0) ? message.failureCount?.toString() : undefined;
+        obj.last_error = message.lastError === "" ? undefined : message.lastError;
+        obj.recovery_mode = message.recoveryMode === false ? undefined : message.recoveryMode;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return exports.TransitionRecoveryState.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return exports.TransitionRecoveryState.decode(message.value);
+    },
+    toProto(message) {
+        return exports.TransitionRecoveryState.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/sparkdream.season.v1.TransitionRecoveryState",
+            value: exports.TransitionRecoveryState.encode(message).finish()
+        };
+    }
+};