@0xkaleab/sdk-js 0.2.7

package/dist/esm/codegen/google/api/httpbody.js

@@ -0,0 +1,150 @@
+// @ts-nocheck
+/* eslint-disable */
+import { Any } from "../protobuf/any";
+import { BinaryReader, BinaryWriter } from "../../binary";
+import { bytesFromBase64, base64FromBytes } from "../../helpers";
+function createBaseHttpBody() {
+    return {
+        contentType: "",
+        data: new Uint8Array(),
+        extensions: []
+    };
+}
+/**
+ * Message that represents an arbitrary HTTP body. It should only be used for
+ * payload formats that can't be represented as JSON, such as raw binary or
+ * an HTML page.
+ *
+ *
+ * This message can be used both in streaming and non-streaming API methods in
+ * the request as well as the response.
+ *
+ * It can be used as a top-level request field, which is convenient if one
+ * wants to extract parameters from either the URL or HTTP template into the
+ * request fields and also want access to the raw HTTP body.
+ *
+ * Example:
+ *
+ *     message GetResourceRequest {
+ *       // A unique request id.
+ *       string request_id = 1;
+ *
+ *       // The raw HTTP body is bound to this field.
+ *       google.api.HttpBody http_body = 2;
+ *
+ *     }
+ *
+ *     service ResourceService {
+ *       rpc GetResource(GetResourceRequest)
+ *         returns (google.api.HttpBody);
+ *       rpc UpdateResource(google.api.HttpBody)
+ *         returns (google.protobuf.Empty);
+ *
+ *     }
+ *
+ * Example with streaming methods:
+ *
+ *     service CaldavService {
+ *       rpc GetCalendar(stream google.api.HttpBody)
+ *         returns (stream google.api.HttpBody);
+ *       rpc UpdateCalendar(stream google.api.HttpBody)
+ *         returns (stream google.api.HttpBody);
+ *
+ *     }
+ *
+ * Use of this type only changes how the request and response bodies are
+ * handled, all other features will continue to work unchanged.
+ * @name HttpBody
+ * @package google.api
+ * @see proto type: google.api.HttpBody
+ */
+export const HttpBody = {
+    typeUrl: "/google.api.HttpBody",
+    is(o) {
+        return o && (o.$typeUrl === HttpBody.typeUrl || typeof o.contentType === "string" && (o.data instanceof Uint8Array || typeof o.data === "string") && Array.isArray(o.extensions) && (!o.extensions.length || Any.is(o.extensions[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === HttpBody.typeUrl || typeof o.content_type === "string" && (o.data instanceof Uint8Array || typeof o.data === "string") && Array.isArray(o.extensions) && (!o.extensions.length || Any.isAmino(o.extensions[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.contentType !== "") {
+            writer.uint32(10).string(message.contentType);
+        }
+        if (message.data.length !== 0) {
+            writer.uint32(18).bytes(message.data);
+        }
+        for (const v of message.extensions) {
+            Any.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseHttpBody();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.contentType = reader.string();
+                    break;
+                case 2:
+                    message.data = reader.bytes();
+                    break;
+                case 3:
+                    message.extensions.push(Any.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseHttpBody();
+        message.contentType = object.contentType ?? "";
+        message.data = object.data ?? new Uint8Array();
+        message.extensions = object.extensions?.map(e => Any.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseHttpBody();
+        if (object.content_type !== undefined && object.content_type !== null) {
+            message.contentType = object.content_type;
+        }
+        if (object.data !== undefined && object.data !== null) {
+            message.data = bytesFromBase64(object.data);
+        }
+        message.extensions = object.extensions?.map(e => Any.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.content_type = message.contentType === "" ? undefined : message.contentType;
+        obj.data = message.data ? base64FromBytes(message.data) : undefined;
+        if (message.extensions) {
+            obj.extensions = message.extensions.map(e => e ? Any.toAmino(e) : undefined);
+        }
+        else {
+            obj.extensions = message.extensions;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return HttpBody.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return HttpBody.decode(message.value);
+    },
+    toProto(message) {
+        return HttpBody.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.HttpBody",
+            value: HttpBody.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};

package/dist/esm/codegen/google/api/launch_stage.js

@@ -0,0 +1,113 @@
+// @ts-nocheck
+/* eslint-disable */
+/**
+ * The launch stage as defined by [Google Cloud Platform
+ * Launch Stages](https://cloud.google.com/terms/launch-stages).
+ */
+export var LaunchStage;
+(function (LaunchStage) {
+    /** LAUNCH_STAGE_UNSPECIFIED - Do not use this default value. */
+    LaunchStage[LaunchStage["LAUNCH_STAGE_UNSPECIFIED"] = 0] = "LAUNCH_STAGE_UNSPECIFIED";
+    /** UNIMPLEMENTED - The feature is not yet implemented. Users can not use it. */
+    LaunchStage[LaunchStage["UNIMPLEMENTED"] = 6] = "UNIMPLEMENTED";
+    /** PRELAUNCH - Prelaunch features are hidden from users and are only visible internally. */
+    LaunchStage[LaunchStage["PRELAUNCH"] = 7] = "PRELAUNCH";
+    /**
+     * EARLY_ACCESS - Early Access features are limited to a closed group of testers. To use
+     * these features, you must sign up in advance and sign a Trusted Tester
+     * agreement (which includes confidentiality provisions). These features may
+     * be unstable, changed in backward-incompatible ways, and are not
+     * guaranteed to be released.
+     */
+    LaunchStage[LaunchStage["EARLY_ACCESS"] = 1] = "EARLY_ACCESS";
+    /**
+     * ALPHA - Alpha is a limited availability test for releases before they are cleared
+     * for widespread use. By Alpha, all significant design issues are resolved
+     * and we are in the process of verifying functionality. Alpha customers
+     * need to apply for access, agree to applicable terms, and have their
+     * projects allowlisted. Alpha releases don't have to be feature complete,
+     * no SLAs are provided, and there are no technical support obligations, but
+     * they will be far enough along that customers can actually use them in
+     * test environments or for limited-use tests -- just like they would in
+     * normal production cases.
+     */
+    LaunchStage[LaunchStage["ALPHA"] = 2] = "ALPHA";
+    /**
+     * BETA - Beta is the point at which we are ready to open a release for any
+     * customer to use. There are no SLA or technical support obligations in a
+     * Beta release. Products will be complete from a feature perspective, but
+     * may have some open outstanding issues. Beta releases are suitable for
+     * limited production use cases.
+     */
+    LaunchStage[LaunchStage["BETA"] = 3] = "BETA";
+    /**
+     * GA - GA features are open to all developers and are considered stable and
+     * fully qualified for production use.
+     */
+    LaunchStage[LaunchStage["GA"] = 4] = "GA";
+    /**
+     * DEPRECATED - Deprecated features are scheduled to be shut down and removed. For more
+     * information, see the "Deprecation Policy" section of our [Terms of
+     * Service](https://cloud.google.com/terms/)
+     * and the [Google Cloud Platform Subject to the Deprecation
+     * Policy](https://cloud.google.com/terms/deprecation) documentation.
+     */
+    LaunchStage[LaunchStage["DEPRECATED"] = 5] = "DEPRECATED";
+    LaunchStage[LaunchStage["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(LaunchStage || (LaunchStage = {}));
+export const LaunchStageAmino = LaunchStage;
+export function launchStageFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "LAUNCH_STAGE_UNSPECIFIED":
+            return LaunchStage.LAUNCH_STAGE_UNSPECIFIED;
+        case 6:
+        case "UNIMPLEMENTED":
+            return LaunchStage.UNIMPLEMENTED;
+        case 7:
+        case "PRELAUNCH":
+            return LaunchStage.PRELAUNCH;
+        case 1:
+        case "EARLY_ACCESS":
+            return LaunchStage.EARLY_ACCESS;
+        case 2:
+        case "ALPHA":
+            return LaunchStage.ALPHA;
+        case 3:
+        case "BETA":
+            return LaunchStage.BETA;
+        case 4:
+        case "GA":
+            return LaunchStage.GA;
+        case 5:
+        case "DEPRECATED":
+            return LaunchStage.DEPRECATED;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return LaunchStage.UNRECOGNIZED;
+    }
+}
+export function launchStageToJSON(object) {
+    switch (object) {
+        case LaunchStage.LAUNCH_STAGE_UNSPECIFIED:
+            return "LAUNCH_STAGE_UNSPECIFIED";
+        case LaunchStage.UNIMPLEMENTED:
+            return "UNIMPLEMENTED";
+        case LaunchStage.PRELAUNCH:
+            return "PRELAUNCH";
+        case LaunchStage.EARLY_ACCESS:
+            return "EARLY_ACCESS";
+        case LaunchStage.ALPHA:
+            return "ALPHA";
+        case LaunchStage.BETA:
+            return "BETA";
+        case LaunchStage.GA:
+            return "GA";
+        case LaunchStage.DEPRECATED:
+            return "DEPRECATED";
+        case LaunchStage.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}

package/dist/esm/codegen/google/api/resource.js

@@ -0,0 +1,399 @@
+// @ts-nocheck
+/* eslint-disable */
+import { isSet } from "../../helpers";
+import { BinaryReader, BinaryWriter } from "../../binary";
+/**
+ * A description of the historical or future-looking state of the
+ * resource pattern.
+ */
+export var ResourceDescriptor_History;
+(function (ResourceDescriptor_History) {
+    /** HISTORY_UNSPECIFIED - The "unset" value. */
+    ResourceDescriptor_History[ResourceDescriptor_History["HISTORY_UNSPECIFIED"] = 0] = "HISTORY_UNSPECIFIED";
+    /**
+     * ORIGINALLY_SINGLE_PATTERN - The resource originally had one pattern and launched as such, and
+     * additional patterns were added later.
+     */
+    ResourceDescriptor_History[ResourceDescriptor_History["ORIGINALLY_SINGLE_PATTERN"] = 1] = "ORIGINALLY_SINGLE_PATTERN";
+    /**
+     * FUTURE_MULTI_PATTERN - The resource has one pattern, but the API owner expects to add more
+     * later. (This is the inverse of ORIGINALLY_SINGLE_PATTERN, and prevents
+     * that from being necessary once there are multiple patterns.)
+     */
+    ResourceDescriptor_History[ResourceDescriptor_History["FUTURE_MULTI_PATTERN"] = 2] = "FUTURE_MULTI_PATTERN";
+    ResourceDescriptor_History[ResourceDescriptor_History["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ResourceDescriptor_History || (ResourceDescriptor_History = {}));
+export const ResourceDescriptor_HistoryAmino = ResourceDescriptor_History;
+export function resourceDescriptor_HistoryFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "HISTORY_UNSPECIFIED":
+            return ResourceDescriptor_History.HISTORY_UNSPECIFIED;
+        case 1:
+        case "ORIGINALLY_SINGLE_PATTERN":
+            return ResourceDescriptor_History.ORIGINALLY_SINGLE_PATTERN;
+        case 2:
+        case "FUTURE_MULTI_PATTERN":
+            return ResourceDescriptor_History.FUTURE_MULTI_PATTERN;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ResourceDescriptor_History.UNRECOGNIZED;
+    }
+}
+export function resourceDescriptor_HistoryToJSON(object) {
+    switch (object) {
+        case ResourceDescriptor_History.HISTORY_UNSPECIFIED:
+            return "HISTORY_UNSPECIFIED";
+        case ResourceDescriptor_History.ORIGINALLY_SINGLE_PATTERN:
+            return "ORIGINALLY_SINGLE_PATTERN";
+        case ResourceDescriptor_History.FUTURE_MULTI_PATTERN:
+            return "FUTURE_MULTI_PATTERN";
+        case ResourceDescriptor_History.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/** A flag representing a specific style that a resource claims to conform to. */
+export var ResourceDescriptor_Style;
+(function (ResourceDescriptor_Style) {
+    /** STYLE_UNSPECIFIED - The unspecified value. Do not use. */
+    ResourceDescriptor_Style[ResourceDescriptor_Style["STYLE_UNSPECIFIED"] = 0] = "STYLE_UNSPECIFIED";
+    /**
+     * DECLARATIVE_FRIENDLY - This resource is intended to be "declarative-friendly".
+     *
+     * Declarative-friendly resources must be more strictly consistent, and
+     * setting this to true communicates to tools that this resource should
+     * adhere to declarative-friendly expectations.
+     *
+     * Note: This is used by the API linter (linter.aip.dev) to enable
+     * additional checks.
+     */
+    ResourceDescriptor_Style[ResourceDescriptor_Style["DECLARATIVE_FRIENDLY"] = 1] = "DECLARATIVE_FRIENDLY";
+    ResourceDescriptor_Style[ResourceDescriptor_Style["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ResourceDescriptor_Style || (ResourceDescriptor_Style = {}));
+export const ResourceDescriptor_StyleAmino = ResourceDescriptor_Style;
+export function resourceDescriptor_StyleFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "STYLE_UNSPECIFIED":
+            return ResourceDescriptor_Style.STYLE_UNSPECIFIED;
+        case 1:
+        case "DECLARATIVE_FRIENDLY":
+            return ResourceDescriptor_Style.DECLARATIVE_FRIENDLY;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ResourceDescriptor_Style.UNRECOGNIZED;
+    }
+}
+export function resourceDescriptor_StyleToJSON(object) {
+    switch (object) {
+        case ResourceDescriptor_Style.STYLE_UNSPECIFIED:
+            return "STYLE_UNSPECIFIED";
+        case ResourceDescriptor_Style.DECLARATIVE_FRIENDLY:
+            return "DECLARATIVE_FRIENDLY";
+        case ResourceDescriptor_Style.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseResourceDescriptor() {
+    return {
+        type: "",
+        pattern: [],
+        nameField: "",
+        history: 0,
+        plural: "",
+        singular: "",
+        style: []
+    };
+}
+/**
+ * A simple descriptor of a resource type.
+ *
+ * ResourceDescriptor annotates a resource message (either by means of a
+ * protobuf annotation or use in the service config), and associates the
+ * resource's schema, the resource type, and the pattern of the resource name.
+ *
+ * Example:
+ *
+ *     message Topic {
+ *       // Indicates this message defines a resource schema.
+ *       // Declares the resource type in the format of {service}/{kind}.
+ *       // For Kubernetes resources, the format is {api group}/{kind}.
+ *       option (google.api.resource) = {
+ *         type: "pubsub.googleapis.com/Topic"
+ *         pattern: "projects/{project}/topics/{topic}"
+ *       };
+ *     }
+ *
+ * The ResourceDescriptor Yaml config will look like:
+ *
+ *     resources:
+ *     - type: "pubsub.googleapis.com/Topic"
+ *       pattern: "projects/{project}/topics/{topic}"
+ *
+ * Sometimes, resources have multiple patterns, typically because they can
+ * live under multiple parents.
+ *
+ * Example:
+ *
+ *     message LogEntry {
+ *       option (google.api.resource) = {
+ *         type: "logging.googleapis.com/LogEntry"
+ *         pattern: "projects/{project}/logs/{log}"
+ *         pattern: "folders/{folder}/logs/{log}"
+ *         pattern: "organizations/{organization}/logs/{log}"
+ *         pattern: "billingAccounts/{billing_account}/logs/{log}"
+ *       };
+ *     }
+ *
+ * The ResourceDescriptor Yaml config will look like:
+ *
+ *     resources:
+ *     - type: 'logging.googleapis.com/LogEntry'
+ *       pattern: "projects/{project}/logs/{log}"
+ *       pattern: "folders/{folder}/logs/{log}"
+ *       pattern: "organizations/{organization}/logs/{log}"
+ *       pattern: "billingAccounts/{billing_account}/logs/{log}"
+ * @name ResourceDescriptor
+ * @package google.api
+ * @see proto type: google.api.ResourceDescriptor
+ */
+export const ResourceDescriptor = {
+    typeUrl: "/google.api.ResourceDescriptor",
+    is(o) {
+        return o && (o.$typeUrl === ResourceDescriptor.typeUrl || typeof o.type === "string" && Array.isArray(o.pattern) && (!o.pattern.length || typeof o.pattern[0] === "string") && typeof o.nameField === "string" && isSet(o.history) && typeof o.plural === "string" && typeof o.singular === "string" && Array.isArray(o.style));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === ResourceDescriptor.typeUrl || typeof o.type === "string" && Array.isArray(o.pattern) && (!o.pattern.length || typeof o.pattern[0] === "string") && typeof o.name_field === "string" && isSet(o.history) && typeof o.plural === "string" && typeof o.singular === "string" && Array.isArray(o.style));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.type !== "") {
+            writer.uint32(10).string(message.type);
+        }
+        for (const v of message.pattern) {
+            writer.uint32(18).string(v);
+        }
+        if (message.nameField !== "") {
+            writer.uint32(26).string(message.nameField);
+        }
+        if (message.history !== 0) {
+            writer.uint32(32).int32(message.history);
+        }
+        if (message.plural !== "") {
+            writer.uint32(42).string(message.plural);
+        }
+        if (message.singular !== "") {
+            writer.uint32(50).string(message.singular);
+        }
+        writer.uint32(82).fork();
+        for (const v of message.style) {
+            writer.int32(v);
+        }
+        writer.ldelim();
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseResourceDescriptor();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.type = reader.string();
+                    break;
+                case 2:
+                    message.pattern.push(reader.string());
+                    break;
+                case 3:
+                    message.nameField = reader.string();
+                    break;
+                case 4:
+                    message.history = reader.int32();
+                    break;
+                case 5:
+                    message.plural = reader.string();
+                    break;
+                case 6:
+                    message.singular = reader.string();
+                    break;
+                case 10:
+                    if ((tag & 7) === 2) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.style.push(reader.int32());
+                        }
+                    }
+                    else {
+                        message.style.push(reader.int32());
+                    }
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseResourceDescriptor();
+        message.type = object.type ?? "";
+        message.pattern = object.pattern?.map(e => e) || [];
+        message.nameField = object.nameField ?? "";
+        message.history = object.history ?? 0;
+        message.plural = object.plural ?? "";
+        message.singular = object.singular ?? "";
+        message.style = object.style?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseResourceDescriptor();
+        if (object.type !== undefined && object.type !== null) {
+            message.type = object.type;
+        }
+        message.pattern = object.pattern?.map(e => e) || [];
+        if (object.name_field !== undefined && object.name_field !== null) {
+            message.nameField = object.name_field;
+        }
+        if (object.history !== undefined && object.history !== null) {
+            message.history = object.history;
+        }
+        if (object.plural !== undefined && object.plural !== null) {
+            message.plural = object.plural;
+        }
+        if (object.singular !== undefined && object.singular !== null) {
+            message.singular = object.singular;
+        }
+        message.style = object.style?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.type = message.type === "" ? undefined : message.type;
+        if (message.pattern) {
+            obj.pattern = message.pattern.map(e => e);
+        }
+        else {
+            obj.pattern = message.pattern;
+        }
+        obj.name_field = message.nameField === "" ? undefined : message.nameField;
+        obj.history = message.history === 0 ? undefined : message.history;
+        obj.plural = message.plural === "" ? undefined : message.plural;
+        obj.singular = message.singular === "" ? undefined : message.singular;
+        if (message.style) {
+            obj.style = message.style.map(e => e);
+        }
+        else {
+            obj.style = message.style;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ResourceDescriptor.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ResourceDescriptor.decode(message.value);
+    },
+    toProto(message) {
+        return ResourceDescriptor.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.ResourceDescriptor",
+            value: ResourceDescriptor.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBaseResourceReference() {
+    return {
+        type: "",
+        childType: ""
+    };
+}
+/**
+ * Defines a proto annotation that describes a string field that refers to
+ * an API resource.
+ * @name ResourceReference
+ * @package google.api
+ * @see proto type: google.api.ResourceReference
+ */
+export const ResourceReference = {
+    typeUrl: "/google.api.ResourceReference",
+    is(o) {
+        return o && (o.$typeUrl === ResourceReference.typeUrl || typeof o.type === "string" && typeof o.childType === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === ResourceReference.typeUrl || typeof o.type === "string" && typeof o.child_type === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.type !== "") {
+            writer.uint32(10).string(message.type);
+        }
+        if (message.childType !== "") {
+            writer.uint32(18).string(message.childType);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseResourceReference();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.type = reader.string();
+                    break;
+                case 2:
+                    message.childType = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseResourceReference();
+        message.type = object.type ?? "";
+        message.childType = object.childType ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseResourceReference();
+        if (object.type !== undefined && object.type !== null) {
+            message.type = object.type;
+        }
+        if (object.child_type !== undefined && object.child_type !== null) {
+            message.childType = object.child_type;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.type = message.type === "" ? undefined : message.type;
+        obj.child_type = message.childType === "" ? undefined : message.childType;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return ResourceReference.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return ResourceReference.decode(message.value);
+    },
+    toProto(message) {
+        return ResourceReference.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.api.ResourceReference",
+            value: ResourceReference.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};